/* =========================== Module _Qt =========================== */

#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 <QuickTime/QuickTime.h>

#ifdef USE_TOOLBOX_OBJECT_GLUE

extern PyObject *_TrackObj_New(Track);

extern int _TrackObj_Convert(PyObject *, Track *);

extern PyObject *_MovieObj_New(Movie);

extern int _MovieObj_Convert(PyObject *, Movie *);

extern PyObject *_MovieCtlObj_New(MovieController);

extern int _MovieCtlObj_Convert(PyObject *, MovieController *);

extern PyObject *_TimeBaseObj_New(TimeBase);

extern int _TimeBaseObj_Convert(PyObject *, TimeBase *);

extern PyObject *_UserDataObj_New(UserData);

extern int _UserDataObj_Convert(PyObject *, UserData *);

extern PyObject *_MediaObj_New(Media);

extern int _MediaObj_Convert(PyObject *, Media *);

#define TrackObj_New _TrackObj_New

#define TrackObj_Convert _TrackObj_Convert

#define MovieObj_New _MovieObj_New

#define MovieObj_Convert _MovieObj_Convert

#define MovieCtlObj_New _MovieCtlObj_New

#define MovieCtlObj_Convert _MovieCtlObj_Convert

#define TimeBaseObj_New _TimeBaseObj_New

#define TimeBaseObj_Convert _TimeBaseObj_Convert

#define UserDataObj_New _UserDataObj_New

#define UserDataObj_Convert _UserDataObj_Convert

#define MediaObj_New _MediaObj_New

#define MediaObj_Convert _MediaObj_Convert

#endif

/* Macro to allow us to GetNextInterestingTime without duration */

#define GetMediaNextInterestingTimeOnly(media, flags, time, rate, rv)                         GetMediaNextInterestingTime(media, flags, time, rate, rv, NULL)

/*

** Parse/generate time records

*/

static PyObject *

QtTimeRecord_New(TimeRecord *itself)

{

        if (itself->base)

                return Py_BuildValue("O&lO&", PyMac_Buildwide, &itself->value, itself->scale,

                        TimeBaseObj_New, itself->base);

        else

                return  Py_BuildValue("O&lO", PyMac_Buildwide, &itself->value, itself->scale,

                        Py_None);

}

static int

QtTimeRecord_Convert(PyObject *v, TimeRecord *p_itself)

{

        PyObject *base = NULL;

        if( !PyArg_ParseTuple(v, "O&l|O", PyMac_Getwide, &p_itself->value, &p_itself->scale,

                        &base) )

                return 0;

        if ( base == NULL || base == Py_None )

                p_itself->base = NULL;

        else

                if ( !TimeBaseObj_Convert(base, &p_itself->base) )

                        return 0;

        return 1;

}

static int

QtMusicMIDIPacket_Convert(PyObject *v, MusicMIDIPacket *p_itself)

{

        int dummy;

        if( !PyArg_ParseTuple(v, "hls#", &p_itself->length, &p_itself->reserved, p_itself->data, dummy) )

                return 0;

        return 1;

}

static PyObject *Qt_Error;

/* -------------------- Object type IdleManager --------------------- */

PyTypeObject IdleManager_Type;

#define IdleManagerObj_Check(x) ((x)->ob_type == &IdleManager_Type || PyObject_TypeCheck((x), &IdleManager_Type))

typedef struct IdleManagerObject {

	PyObject_HEAD

	IdleManager ob_itself;

} IdleManagerObject;

PyObject *IdleManagerObj_New(IdleManager itself)

{

	IdleManagerObject *it;

	if (itself == NULL) {

	                                PyErr_SetString(Qt_Error,"Cannot create IdleManager from NULL pointer");

	                                return NULL;

	                        }

	it = PyObject_NEW(IdleManagerObject, &IdleManager_Type);

	if (it == NULL) return NULL;

	it->ob_itself = itself;

	return (PyObject *)it;

}

int IdleManagerObj_Convert(PyObject *v, IdleManager *p_itself)

{

	if (v == Py_None)

	{

		*p_itself = NULL;

		return 1;

	}

	if (!IdleManagerObj_Check(v))

	{

		PyErr_SetString(PyExc_TypeError, "IdleManager required");

		return 0;

	}

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

	return 1;

}

static void IdleManagerObj_dealloc(IdleManagerObject *self)

{

	/* Cleanup of self->ob_itself goes here */

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

}

static PyMethodDef IdleManagerObj_methods[] = {

	{NULL, NULL, 0}

};

#define IdleManagerObj_getsetlist NULL

#define IdleManagerObj_compare NULL

#define IdleManagerObj_repr NULL

#define IdleManagerObj_hash NULL

#define IdleManagerObj_tp_init 0

#define IdleManagerObj_tp_alloc PyType_GenericAlloc

static PyObject *IdleManagerObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

{

	PyObject *_self;

	IdleManager itself;

	char *kw[] = {"itself", 0};

	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, IdleManagerObj_Convert, &itself)) return NULL;

	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;

	((IdleManagerObject *)_self)->ob_itself = itself;

	return _self;

}

#define IdleManagerObj_tp_free PyObject_Del

PyTypeObject IdleManager_Type = {

	PyObject_HEAD_INIT(NULL)

	0, /*ob_size*/

	"_Qt.IdleManager", /*tp_name*/

	sizeof(IdleManagerObject), /*tp_basicsize*/

	0, /*tp_itemsize*/

	/* methods */

	(destructor) IdleManagerObj_dealloc, /*tp_dealloc*/

	0, /*tp_print*/

	(getattrfunc)0, /*tp_getattr*/

	(setattrfunc)0, /*tp_setattr*/

	(cmpfunc) IdleManagerObj_compare, /*tp_compare*/

	(reprfunc) IdleManagerObj_repr, /*tp_repr*/

	(PyNumberMethods *)0, /* tp_as_number */

	(PySequenceMethods *)0, /* tp_as_sequence */

	(PyMappingMethods *)0, /* tp_as_mapping */

	(hashfunc) IdleManagerObj_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*/

	IdleManagerObj_methods, /* tp_methods */

	0, /*tp_members*/

	IdleManagerObj_getsetlist, /*tp_getset*/

	0, /*tp_base*/

	0, /*tp_dict*/

	0, /*tp_descr_get*/

	0, /*tp_descr_set*/

	0, /*tp_dictoffset*/

	IdleManagerObj_tp_init, /* tp_init */

	IdleManagerObj_tp_alloc, /* tp_alloc */

	IdleManagerObj_tp_new, /* tp_new */

	IdleManagerObj_tp_free, /* tp_free */

};

/* ------------------ End object type IdleManager ------------------- */

/* ------------------ Object type MovieController ------------------- */

PyTypeObject MovieController_Type;

#define MovieCtlObj_Check(x) ((x)->ob_type == &MovieController_Type || PyObject_TypeCheck((x), &MovieController_Type))

typedef struct MovieControllerObject {

	PyObject_HEAD

	MovieController ob_itself;

} MovieControllerObject;

PyObject *MovieCtlObj_New(MovieController itself)

{

	MovieControllerObject *it;

	if (itself == NULL) {

	                                PyErr_SetString(Qt_Error,"Cannot create MovieController from NULL pointer");

	                                return NULL;

	                        }

	it = PyObject_NEW(MovieControllerObject, &MovieController_Type);

	if (it == NULL) return NULL;

	it->ob_itself = itself;

	return (PyObject *)it;

}

int MovieCtlObj_Convert(PyObject *v, MovieController *p_itself)

{

	if (v == Py_None)

	{

		*p_itself = NULL;

		return 1;

	}

	if (!MovieCtlObj_Check(v))

	{

		PyErr_SetString(PyExc_TypeError, "MovieController required");

		return 0;

	}

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

	return 1;

}

static void MovieCtlObj_dealloc(MovieControllerObject *self)

{

	if (self->ob_itself) DisposeMovieController(self->ob_itself);

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

}

static PyObject *MovieCtlObj_MCSetMovie(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ComponentResult _rv;

	Movie theMovie;

	WindowPtr movieWindow;

	Point where;

#ifndef MCSetMovie

	PyMac_PRECHECK(MCSetMovie);

#endif

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

	                      MovieObj_Convert, &theMovie,

	                      WinObj_Convert, &movieWindow,

	                      PyMac_GetPoint, &where))

		return NULL;

	_rv = MCSetMovie(_self->ob_itself,

	                 theMovie,

	                 movieWindow,

	                 where);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *MovieCtlObj_MCGetIndMovie(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	Movie _rv;

	short index;

#ifndef MCGetIndMovie

	PyMac_PRECHECK(MCGetIndMovie);

#endif

	if (!PyArg_ParseTuple(_args, "h",

	                      &index))

		return NULL;

	_rv = MCGetIndMovie(_self->ob_itself,

	                    index);

	_res = Py_BuildValue("O&",

	                     MovieObj_New, _rv);

	return _res;

}

static PyObject *MovieCtlObj_MCRemoveAllMovies(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ComponentResult _rv;

#ifndef MCRemoveAllMovies

	PyMac_PRECHECK(MCRemoveAllMovies);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = MCRemoveAllMovies(_self->ob_itself);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *MovieCtlObj_MCRemoveAMovie(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ComponentResult _rv;

	Movie m;

#ifndef MCRemoveAMovie

	PyMac_PRECHECK(MCRemoveAMovie);

#endif

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

	                      MovieObj_Convert, &m))

		return NULL;

	_rv = MCRemoveAMovie(_self->ob_itself,

	                     m);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *MovieCtlObj_MCRemoveMovie(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ComponentResult _rv;

#ifndef MCRemoveMovie

	PyMac_PRECHECK(MCRemoveMovie);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = MCRemoveMovie(_self->ob_itself);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *MovieCtlObj_MCIsPlayerEvent(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ComponentResult _rv;

	EventRecord e;

#ifndef MCIsPlayerEvent

	PyMac_PRECHECK(MCIsPlayerEvent);

#endif

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

	                      PyMac_GetEventRecord, &e))

		return NULL;

	_rv = MCIsPlayerEvent(_self->ob_itself,

	                      &e);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *MovieCtlObj_MCDoAction(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ComponentResult _rv;

	short action;

	void * params;

#ifndef MCDoAction

	PyMac_PRECHECK(MCDoAction);

#endif

	if (!PyArg_ParseTuple(_args, "hs",

	                      &action,

	                      &params))

		return NULL;

	_rv = MCDoAction(_self->ob_itself,

	                 action,

	                 params);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *MovieCtlObj_MCSetControllerAttached(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ComponentResult _rv;

	Boolean attach;

#ifndef MCSetControllerAttached

	PyMac_PRECHECK(MCSetControllerAttached);

#endif

	if (!PyArg_ParseTuple(_args, "b",

	                      &attach))

		return NULL;

	_rv = MCSetControllerAttached(_self->ob_itself,

	                              attach);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *MovieCtlObj_MCIsControllerAttached(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ComponentResult _rv;

#ifndef MCIsControllerAttached

	PyMac_PRECHECK(MCIsControllerAttached);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = MCIsControllerAttached(_self->ob_itself);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *MovieCtlObj_MCSetControllerPort(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ComponentResult _rv;

	CGrafPtr gp;

#ifndef MCSetControllerPort

	PyMac_PRECHECK(MCSetControllerPort);

#endif

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

	                      GrafObj_Convert, &gp))

		return NULL;

	_rv = MCSetControllerPort(_self->ob_itself,

	                          gp);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *MovieCtlObj_MCGetControllerPort(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	CGrafPtr _rv;

#ifndef MCGetControllerPort

	PyMac_PRECHECK(MCGetControllerPort);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = MCGetControllerPort(_self->ob_itself);

	_res = Py_BuildValue("O&",

	                     GrafObj_New, _rv);

	return _res;

}

static PyObject *MovieCtlObj_MCSetVisible(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ComponentResult _rv;

	Boolean visible;

#ifndef MCSetVisible

	PyMac_PRECHECK(MCSetVisible);

#endif

	if (!PyArg_ParseTuple(_args, "b",

	                      &visible))

		return NULL;

	_rv = MCSetVisible(_self->ob_itself,

	                   visible);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *MovieCtlObj_MCGetVisible(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ComponentResult _rv;

#ifndef MCGetVisible

	PyMac_PRECHECK(MCGetVisible);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = MCGetVisible(_self->ob_itself);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *MovieCtlObj_MCGetControllerBoundsRect(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ComponentResult _rv;

	Rect bounds;

#ifndef MCGetControllerBoundsRect

	PyMac_PRECHECK(MCGetControllerBoundsRect);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = MCGetControllerBoundsRect(_self->ob_itself,

	                                &bounds);

	_res = Py_BuildValue("lO&",

	                     _rv,

	                     PyMac_BuildRect, &bounds);

	return _res;

}

static PyObject *MovieCtlObj_MCSetControllerBoundsRect(MovieControllerObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ComponentResult _rv;

	Rect bounds;

#ifndef MCSetControllerBoundsRect

	PyMac_PRECHECK(MCSetControllerBoundsRect);

#endif

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

	                      PyMac_GetRect, &bounds))

		return NULL;

	_rv = MCSetControllerBoundsRect(_self->ob_itself,

	                                &bounds);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;