/* ========================== Module _Drag ========================== */

#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>

/* Callback glue routines */

DragTrackingHandlerUPP dragglue_TrackingHandlerUPP;

DragReceiveHandlerUPP dragglue_ReceiveHandlerUPP;

DragSendDataUPP dragglue_SendDataUPP;

#if 0

DragInputUPP dragglue_InputUPP;

DragDrawingUPP dragglue_DrawingUPP;

#endif

#ifdef USE_TOOLBOX_OBJECT_GLUE

extern PyObject *_DragObj_New(DragRef);

extern int _DragObj_Convert(PyObject *, DragRef *);

#define DragObj_New _DragObj_New

#define DragObj_Convert _DragObj_Convert

#endif

static PyObject *Drag_Error;

/* ---------------------- Object type DragObj ----------------------- */

PyTypeObject DragObj_Type;

#define DragObj_Check(x) ((x)->ob_type == &DragObj_Type || PyObject_TypeCheck((x), &DragObj_Type))

typedef struct DragObjObject {

	PyObject_HEAD

	DragRef ob_itself;

	PyObject *sendproc;

} DragObjObject;

PyObject *DragObj_New(DragRef itself)

{

	DragObjObject *it;

	if (itself == NULL) {

	                                PyErr_SetString(Drag_Error,"Cannot create null Drag");

	                                return NULL;

	                        }

	it = PyObject_NEW(DragObjObject, &DragObj_Type);

	if (it == NULL) return NULL;

	it->ob_itself = itself;

	it->sendproc = NULL;

	return (PyObject *)it;

}

int DragObj_Convert(PyObject *v, DragRef *p_itself)

{

	if (!DragObj_Check(v))

	{

		PyErr_SetString(PyExc_TypeError, "DragObj required");

		return 0;

	}

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

	return 1;

}

static void DragObj_dealloc(DragObjObject *self)

{

	Py_XDECREF(self->sendproc);

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

}

static PyObject *DragObj_DisposeDrag(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

#ifndef DisposeDrag

	PyMac_PRECHECK(DisposeDrag);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = DisposeDrag(_self->ob_itself);

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

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *DragObj_AddDragItemFlavor(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	ItemReference theItemRef;

	FlavorType theType;

	char *dataPtr__in__;

	long dataPtr__len__;

	int dataPtr__in_len__;

	FlavorFlags theFlags;

#ifndef AddDragItemFlavor

	PyMac_PRECHECK(AddDragItemFlavor);

#endif

	if (!PyArg_ParseTuple(_args, "lO&z#l",

	                      &theItemRef,

	                      PyMac_GetOSType, &theType,

	                      &dataPtr__in__, &dataPtr__in_len__,

	                      &theFlags))

		return NULL;

	dataPtr__len__ = dataPtr__in_len__;

	_err = AddDragItemFlavor(_self->ob_itself,

	                         theItemRef,

	                         theType,

	                         dataPtr__in__, dataPtr__len__,

	                         theFlags);

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

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *DragObj_SetDragItemFlavorData(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	ItemReference theItemRef;

	FlavorType theType;

	char *dataPtr__in__;

	long dataPtr__len__;

	int dataPtr__in_len__;

	UInt32 dataOffset;

#ifndef SetDragItemFlavorData

	PyMac_PRECHECK(SetDragItemFlavorData);

#endif

	if (!PyArg_ParseTuple(_args, "lO&z#l",

	                      &theItemRef,

	                      PyMac_GetOSType, &theType,

	                      &dataPtr__in__, &dataPtr__in_len__,

	                      &dataOffset))

		return NULL;

	dataPtr__len__ = dataPtr__in_len__;

	_err = SetDragItemFlavorData(_self->ob_itself,

	                             theItemRef,

	                             theType,

	                             dataPtr__in__, dataPtr__len__,

	                             dataOffset);

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

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *DragObj_SetDragImage(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	PixMapHandle imagePixMap;

	RgnHandle imageRgn;

	Point imageOffsetPt;

	DragImageFlags theImageFlags;

#ifndef SetDragImage

	PyMac_PRECHECK(SetDragImage);

#endif

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

	                      ResObj_Convert, &imagePixMap,

	                      ResObj_Convert, &imageRgn,

	                      PyMac_GetPoint, &imageOffsetPt,

	                      &theImageFlags))

		return NULL;

	_err = SetDragImage(_self->ob_itself,

	                    imagePixMap,

	                    imageRgn,

	                    imageOffsetPt,

	                    theImageFlags);

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

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *DragObj_ChangeDragBehaviors(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	DragBehaviors inBehaviorsToSet;

	DragBehaviors inBehaviorsToClear;

#ifndef ChangeDragBehaviors

	PyMac_PRECHECK(ChangeDragBehaviors);

#endif

	if (!PyArg_ParseTuple(_args, "ll",

	                      &inBehaviorsToSet,

	                      &inBehaviorsToClear))

		return NULL;

	_err = ChangeDragBehaviors(_self->ob_itself,

	                           inBehaviorsToSet,

	                           inBehaviorsToClear);

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

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *DragObj_TrackDrag(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	EventRecord theEvent;

	RgnHandle theRegion;

#ifndef TrackDrag

	PyMac_PRECHECK(TrackDrag);

#endif

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

	                      PyMac_GetEventRecord, &theEvent,

	                      ResObj_Convert, &theRegion))

		return NULL;

	_err = TrackDrag(_self->ob_itself,

	                 &theEvent,

	                 theRegion);

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

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *DragObj_CountDragItems(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	UInt16 numItems;

#ifndef CountDragItems

	PyMac_PRECHECK(CountDragItems);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = CountDragItems(_self->ob_itself,

	                      &numItems);

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

	_res = Py_BuildValue("H",

	                     numItems);

	return _res;

}

static PyObject *DragObj_GetDragItemReferenceNumber(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	UInt16 index;

	ItemReference theItemRef;

#ifndef GetDragItemReferenceNumber

	PyMac_PRECHECK(GetDragItemReferenceNumber);

#endif

	if (!PyArg_ParseTuple(_args, "H",

	                      &index))

		return NULL;

	_err = GetDragItemReferenceNumber(_self->ob_itself,

	                                  index,

	                                  &theItemRef);

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

	_res = Py_BuildValue("l",

	                     theItemRef);

	return _res;

}

static PyObject *DragObj_CountDragItemFlavors(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	ItemReference theItemRef;

	UInt16 numFlavors;

#ifndef CountDragItemFlavors

	PyMac_PRECHECK(CountDragItemFlavors);

#endif

	if (!PyArg_ParseTuple(_args, "l",

	                      &theItemRef))

		return NULL;

	_err = CountDragItemFlavors(_self->ob_itself,

	                            theItemRef,

	                            &numFlavors);

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

	_res = Py_BuildValue("H",

	                     numFlavors);

	return _res;

}

static PyObject *DragObj_GetFlavorType(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	ItemReference theItemRef;

	UInt16 index;

	FlavorType theType;

#ifndef GetFlavorType

	PyMac_PRECHECK(GetFlavorType);

#endif

	if (!PyArg_ParseTuple(_args, "lH",

	                      &theItemRef,

	                      &index))

		return NULL;

	_err = GetFlavorType(_self->ob_itself,

	                     theItemRef,

	                     index,

	                     &theType);

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

	_res = Py_BuildValue("O&",

	                     PyMac_BuildOSType, theType);

	return _res;

}

static PyObject *DragObj_GetFlavorFlags(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	ItemReference theItemRef;

	FlavorType theType;

	FlavorFlags theFlags;

#ifndef GetFlavorFlags

	PyMac_PRECHECK(GetFlavorFlags);

#endif

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

	                      &theItemRef,

	                      PyMac_GetOSType, &theType))

		return NULL;

	_err = GetFlavorFlags(_self->ob_itself,

	                      theItemRef,

	                      theType,

	                      &theFlags);

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

	_res = Py_BuildValue("l",

	                     theFlags);

	return _res;

}

static PyObject *DragObj_GetFlavorDataSize(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	ItemReference theItemRef;

	FlavorType theType;

	Size dataSize;

#ifndef GetFlavorDataSize

	PyMac_PRECHECK(GetFlavorDataSize);

#endif

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

	                      &theItemRef,

	                      PyMac_GetOSType, &theType))

		return NULL;

	_err = GetFlavorDataSize(_self->ob_itself,

	                         theItemRef,

	                         theType,

	                         &dataSize);

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

	_res = Py_BuildValue("l",

	                     dataSize);

	return _res;

}

static PyObject *DragObj_GetFlavorData(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	ItemReference theItemRef;

	FlavorType theType;

	char *dataPtr__out__;

	long dataPtr__len__;

	int dataPtr__in_len__;

	UInt32 dataOffset;

#ifndef GetFlavorData

	PyMac_PRECHECK(GetFlavorData);

#endif

	if (!PyArg_ParseTuple(_args, "lO&il",

	                      &theItemRef,

	                      PyMac_GetOSType, &theType,

	                      &dataPtr__in_len__,

	                      &dataOffset))

		return NULL;

	if ((dataPtr__out__ = malloc(dataPtr__in_len__)) == NULL)

	{

		PyErr_NoMemory();

		goto dataPtr__error__;

	}

	dataPtr__len__ = dataPtr__in_len__;

	_err = GetFlavorData(_self->ob_itself,

	                     theItemRef,

	                     theType,

	                     dataPtr__out__, &dataPtr__len__,

	                     dataOffset);

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

	_res = Py_BuildValue("s#",

	                     dataPtr__out__, (int)dataPtr__len__);

	free(dataPtr__out__);

 dataPtr__error__: ;

	return _res;

}

static PyObject *DragObj_GetDragItemBounds(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	ItemReference theItemRef;

	Rect itemBounds;

#ifndef GetDragItemBounds

	PyMac_PRECHECK(GetDragItemBounds);

#endif

	if (!PyArg_ParseTuple(_args, "l",

	                      &theItemRef))

		return NULL;

	_err = GetDragItemBounds(_self->ob_itself,

	                         theItemRef,

	                         &itemBounds);

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

	_res = Py_BuildValue("O&",

	                     PyMac_BuildRect, &itemBounds);

	return _res;

}

static PyObject *DragObj_SetDragItemBounds(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	ItemReference theItemRef;

	Rect itemBounds;

#ifndef SetDragItemBounds

	PyMac_PRECHECK(SetDragItemBounds);

#endif

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

	                      &theItemRef,

	                      PyMac_GetRect, &itemBounds))

		return NULL;

	_err = SetDragItemBounds(_self->ob_itself,

	                         theItemRef,

	                         &itemBounds);

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

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *DragObj_GetDropLocation(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	AEDesc dropLocation;

#ifndef GetDropLocation

	PyMac_PRECHECK(GetDropLocation);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = GetDropLocation(_self->ob_itself,

	                       &dropLocation);

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

	_res = Py_BuildValue("O&",

	                     AEDesc_New, &dropLocation);

	return _res;

}

static PyObject *DragObj_SetDropLocation(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	AEDesc dropLocation;

#ifndef SetDropLocation

	PyMac_PRECHECK(SetDropLocation);

#endif

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

	                      AEDesc_Convert, &dropLocation))

		return NULL;

	_err = SetDropLocation(_self->ob_itself,

	                       &dropLocation);

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

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *DragObj_GetDragAttributes(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	DragAttributes flags;

#ifndef GetDragAttributes

	PyMac_PRECHECK(GetDragAttributes);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = GetDragAttributes(_self->ob_itself,

	                         &flags);

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

	_res = Py_BuildValue("l",

	                     flags);

	return _res;

}

static PyObject *DragObj_GetDragMouse(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	Point mouse;

	Point globalPinnedMouse;

#ifndef GetDragMouse

	PyMac_PRECHECK(GetDragMouse);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = GetDragMouse(_self->ob_itself,

	                    &mouse,

	                    &globalPinnedMouse);

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

	_res = Py_BuildValue("O&O&",

	                     PyMac_BuildPoint, mouse,

	                     PyMac_BuildPoint, globalPinnedMouse);

	return _res;

}

static PyObject *DragObj_SetDragMouse(DragObjObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	Point globalPinnedMouse;

#ifndef SetDragMouse

	PyMac_PRECHECK(SetDragMouse);