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

#include "Python.h"
#include "pymactoolbox.h"


#if APPLE_SUPPORTS_QUICKTIME


/* 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;
}

static PyObject *MovieCtlObj_MCGetControllerBoundsRgn(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    RgnHandle _rv;
#ifndef MCGetControllerBoundsRgn
    PyMac_PRECHECK(MCGetControllerBoundsRgn);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCGetControllerBoundsRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetWindowRgn(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    WindowPtr w;
#ifndef MCGetWindowRgn
    PyMac_PRECHECK(MCGetWindowRgn);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          WinObj_Convert, &w))
        return NULL;
    _rv = MCGetWindowRgn(_self->ob_itself,
                         w);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCMovieChanged(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Movie m;
#ifndef MCMovieChanged
    PyMac_PRECHECK(MCMovieChanged);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          MovieObj_Convert, &m))
        return NULL;
    _rv = MCMovieChanged(_self->ob_itself,
                         m);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCSetDuration(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TimeValue duration;
#ifndef MCSetDuration
    PyMac_PRECHECK(MCSetDuration);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &duration))
        return NULL;
    _rv = MCSetDuration(_self->ob_itself,
                        duration);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetCurrentTime(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue _rv;
    TimeScale scale;
#ifndef MCGetCurrentTime
    PyMac_PRECHECK(MCGetCurrentTime);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCGetCurrentTime(_self->ob_itself,
                           &scale);
    _res = Py_BuildValue("ll",
                         _rv,
                         scale);
    return _res;
}

static PyObject *MovieCtlObj_MCNewAttachedController(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Movie theMovie;
    WindowPtr w;
    Point where;
#ifndef MCNewAttachedController
    PyMac_PRECHECK(MCNewAttachedController);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          MovieObj_Convert, &theMovie,
                          WinObj_Convert, &w,
                          PyMac_GetPoint, &where))
        return NULL;
    _rv = MCNewAttachedController(_self->ob_itself,
                                  theMovie,
                                  w,
                                  where);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCDraw(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    WindowPtr w;
#ifndef MCDraw
    PyMac_PRECHECK(MCDraw);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          WinObj_Convert, &w))
        return NULL;
    _rv = MCDraw(_self->ob_itself,
                 w);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCActivate(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    WindowPtr w;
    Boolean activate;
#ifndef MCActivate
    PyMac_PRECHECK(MCActivate);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          WinObj_Convert, &w,
                          &activate))
        return NULL;
    _rv = MCActivate(_self->ob_itself,
                     w,
                     activate);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCIdle(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
#ifndef MCIdle
    PyMac_PRECHECK(MCIdle);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCIdle(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCKey(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SInt8 key;
    long modifiers;
#ifndef MCKey
    PyMac_PRECHECK(MCKey);
#endif
    if (!PyArg_ParseTuple(_args, "bl",
                          &key,
                          &modifiers))
        return NULL;
    _rv = MCKey(_self->ob_itself,
                key,
                modifiers);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCClick(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    WindowPtr w;
    Point where;
    long when;
    long modifiers;
#ifndef MCClick
    PyMac_PRECHECK(MCClick);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&ll",
                          WinObj_Convert, &w,
                          PyMac_GetPoint, &where,
                          &when,
                          &modifiers))
        return NULL;
    _rv = MCClick(_self->ob_itself,
                  w,
                  where,
                  when,
                  modifiers);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCEnableEditing(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Boolean enabled;
#ifndef MCEnableEditing
    PyMac_PRECHECK(MCEnableEditing);
#endif
    if (!PyArg_ParseTuple(_args, "b",
                          &enabled))
        return NULL;
    _rv = MCEnableEditing(_self->ob_itself,
                          enabled);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

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

static PyObject *MovieCtlObj_MCCopy(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Movie _rv;
#ifndef MCCopy
    PyMac_PRECHECK(MCCopy);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCCopy(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCCut(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Movie _rv;
#ifndef MCCut
    PyMac_PRECHECK(MCCut);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCCut(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCPaste(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Movie srcMovie;
#ifndef MCPaste
    PyMac_PRECHECK(MCPaste);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          MovieObj_Convert, &srcMovie))
        return NULL;
    _rv = MCPaste(_self->ob_itself,
                  srcMovie);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCClear(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
#ifndef MCClear
    PyMac_PRECHECK(MCClear);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCClear(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCUndo(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
#ifndef MCUndo
    PyMac_PRECHECK(MCUndo);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCUndo(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCPositionController(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Rect movieRect;
    Rect controllerRect;
    long someFlags;
#ifndef MCPositionController
    PyMac_PRECHECK(MCPositionController);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          PyMac_GetRect, &movieRect,
                          PyMac_GetRect, &controllerRect,
                          &someFlags))
        return NULL;
    _rv = MCPositionController(_self->ob_itself,
                               &movieRect,
                               &controllerRect,
                               someFlags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetControllerInfo(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    long someFlags;
#ifndef MCGetControllerInfo
    PyMac_PRECHECK(MCGetControllerInfo);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCGetControllerInfo(_self->ob_itself,
                              &someFlags);
    _res = Py_BuildValue("ll",
                         _rv,
                         someFlags);
    return _res;
}

static PyObject *MovieCtlObj_MCSetClip(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    RgnHandle theClip;
    RgnHandle movieClip;
#ifndef MCSetClip
    PyMac_PRECHECK(MCSetClip);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &theClip,
                          ResObj_Convert, &movieClip))
        return NULL;
    _rv = MCSetClip(_self->ob_itself,
                    theClip,
                    movieClip);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetClip(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    RgnHandle theClip;
    RgnHandle movieClip;
#ifndef MCGetClip
    PyMac_PRECHECK(MCGetClip);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCGetClip(_self->ob_itself,
                    &theClip,
                    &movieClip);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, theClip,
                         ResObj_New, movieClip);
    return _res;
}

static PyObject *MovieCtlObj_MCDrawBadge(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    RgnHandle movieRgn;
    RgnHandle badgeRgn;
#ifndef MCDrawBadge
    PyMac_PRECHECK(MCDrawBadge);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &movieRgn))
        return NULL;
    _rv = MCDrawBadge(_self->ob_itself,
                      movieRgn,
                      &badgeRgn);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, badgeRgn);
    return _res;
}

static PyObject *MovieCtlObj_MCSetUpEditMenu(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    long modifiers;
    MenuHandle mh;
#ifndef MCSetUpEditMenu
    PyMac_PRECHECK(MCSetUpEditMenu);
#endif
    if (!PyArg_ParseTuple(_args, "lO&",
                          &modifiers,
                          MenuObj_Convert, &mh))
        return NULL;
    _rv = MCSetUpEditMenu(_self->ob_itself,
                          modifiers,
                          mh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetMenuString(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    long modifiers;
    short item;
    Str255 aString;
#ifndef MCGetMenuString
    PyMac_PRECHECK(MCGetMenuString);
#endif
    if (!PyArg_ParseTuple(_args, "lhO&",
                          &modifiers,
                          &item,
                          PyMac_GetStr255, aString))
        return NULL;
    _rv = MCGetMenuString(_self->ob_itself,
                          modifiers,
                          item,
                          aString);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCPtInController(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Point thePt;
    Boolean inController;
#ifndef MCPtInController
    PyMac_PRECHECK(MCPtInController);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetPoint, &thePt))
        return NULL;
    _rv = MCPtInController(_self->ob_itself,
                           thePt,
                           &inController);
    _res = Py_BuildValue("lb",
                         _rv,
                         inController);
    return _res;
}

static PyObject *MovieCtlObj_MCInvalidate(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    WindowPtr w;
    RgnHandle invalidRgn;
#ifndef MCInvalidate
    PyMac_PRECHECK(MCInvalidate);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          WinObj_Convert, &w,
                          ResObj_Convert, &invalidRgn))
        return NULL;
    _rv = MCInvalidate(_self->ob_itself,
                       w,
                       invalidRgn);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCAdjustCursor(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    WindowPtr w;
    Point where;
    long modifiers;
#ifndef MCAdjustCursor
    PyMac_PRECHECK(MCAdjustCursor);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          WinObj_Convert, &w,
                          PyMac_GetPoint, &where,
                          &modifiers))
        return NULL;
    _rv = MCAdjustCursor(_self->ob_itself,
                         w,
                         where,
                         modifiers);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetInterfaceElement(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MCInterfaceElement whichElement;
    void * element;
#ifndef MCGetInterfaceElement
    PyMac_PRECHECK(MCGetInterfaceElement);
#endif
    if (!PyArg_ParseTuple(_args, "ls",
                          &whichElement,
                          &element))
        return NULL;
    _rv = MCGetInterfaceElement(_self->ob_itself,
                                whichElement,
                                element);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCAddMovieSegment(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Movie srcMovie;
    Boolean scaled;
#ifndef MCAddMovieSegment
    PyMac_PRECHECK(MCAddMovieSegment);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          MovieObj_Convert, &srcMovie,
                          &scaled))
        return NULL;
    _rv = MCAddMovieSegment(_self->ob_itself,
                            srcMovie,
                            scaled);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCTrimMovieSegment(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
#ifndef MCTrimMovieSegment
    PyMac_PRECHECK(MCTrimMovieSegment);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCTrimMovieSegment(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCSetIdleManager(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    IdleManager im;
#ifndef MCSetIdleManager
    PyMac_PRECHECK(MCSetIdleManager);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          IdleManagerObj_Convert, &im))
        return NULL;
    _rv = MCSetIdleManager(_self->ob_itself,
                           im);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCSetControllerCapabilities(MovieControllerObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    long flags;
    long flagsMask;
#ifndef MCSetControllerCapabilities
    PyMac_PRECHECK(MCSetControllerCapabilities);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &flags,
                          &flagsMask))
        return NULL;
    _rv = MCSetControllerCapabilities(_self->ob_itself,
                                      flags,
                                      flagsMask);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyMethodDef MovieCtlObj_methods[] = {
    {"MCSetMovie", (PyCFunction)MovieCtlObj_MCSetMovie, 1,
     PyDoc_STR("(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)")},
    {"MCGetIndMovie", (PyCFunction)MovieCtlObj_MCGetIndMovie, 1,
     PyDoc_STR("(short index) -> (Movie _rv)")},
    {"MCRemoveAllMovies", (PyCFunction)MovieCtlObj_MCRemoveAllMovies, 1,
     PyDoc_STR("() -> (ComponentResult _rv)")},
    {"MCRemoveAMovie", (PyCFunction)MovieCtlObj_MCRemoveAMovie, 1,
     PyDoc_STR("(Movie m) -> (ComponentResult _rv)")},
    {"MCRemoveMovie", (PyCFunction)MovieCtlObj_MCRemoveMovie, 1,
     PyDoc_STR("() -> (ComponentResult _rv)")},
    {"MCIsPlayerEvent", (PyCFunction)MovieCtlObj_MCIsPlayerEvent, 1,
     PyDoc_STR("(EventRecord e) -> (ComponentResult _rv)")},
    {"MCDoAction", (PyCFunction)MovieCtlObj_MCDoAction, 1,
     PyDoc_STR("(short action, void * params) -> (ComponentResult _rv)")},
    {"MCSetControllerAttached", (PyCFunction)MovieCtlObj_MCSetControllerAttached, 1,
     PyDoc_STR("(Boolean attach) -> (ComponentResult _rv)")},
    {"MCIsControllerAttached", (PyCFunction)MovieCtlObj_MCIsControllerAttached, 1,
     PyDoc_STR("() -> (ComponentResult _rv)")},
    {"MCSetControllerPort", (PyCFunction)MovieCtlObj_MCSetControllerPort, 1,
     PyDoc_STR("(CGrafPtr gp) -> (ComponentResult _rv)")},
    {"MCGetControllerPort", (PyCFunction)MovieCtlObj_MCGetControllerPort, 1,
     PyDoc_STR("() -> (CGrafPtr _rv)")},
    {"MCSetVisible", (PyCFunction)MovieCtlObj_MCSetVisible, 1,
     PyDoc_STR("(Boolean visible) -> (ComponentResult _rv)")},
    {"MCGetVisible", (PyCFunction)MovieCtlObj_MCGetVisible, 1,
     PyDoc_STR("() -> (ComponentResult _rv)")},
    {"MCGetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRect, 1,
     PyDoc_STR("() -> (ComponentResult _rv, Rect bounds)")},
    {"MCSetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCSetControllerBoundsRect, 1,
     PyDoc_STR("(Rect bounds) -> (ComponentResult _rv)")},
    {"MCGetControllerBoundsRgn", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRgn, 1,
     PyDoc_STR("() -> (RgnHandle _rv)")},
    {"MCGetWindowRgn", (PyCFunction)MovieCtlObj_MCGetWindowRgn, 1,
     PyDoc_STR("(WindowPtr w) -> (RgnHandle _rv)")},
    {"MCMovieChanged", (PyCFunction)MovieCtlObj_MCMovieChanged, 1,
     PyDoc_STR("(Movie m) -> (ComponentResult _rv)")},
    {"MCSetDuration", (PyCFunction)MovieCtlObj_MCSetDuration, 1,
     PyDoc_STR("(TimeValue duration) -> (ComponentResult _rv)")},
    {"MCGetCurrentTime", (PyCFunction)MovieCtlObj_MCGetCurrentTime, 1,
     PyDoc_STR("() -> (TimeValue _rv, TimeScale scale)")},
    {"MCNewAttachedController", (PyCFunction)MovieCtlObj_MCNewAttachedController, 1,
     PyDoc_STR("(Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)")},
    {"MCDraw", (PyCFunction)MovieCtlObj_MCDraw, 1,
     PyDoc_STR("(WindowPtr w) -> (ComponentResult _rv)")},
    {"MCActivate", (PyCFunction)MovieCtlObj_MCActivate, 1,
     PyDoc_STR("(WindowPtr w, Boolean activate) -> (ComponentResult _rv)")},
    {"MCIdle", (PyCFunction)MovieCtlObj_MCIdle, 1,
     PyDoc_STR("() -> (ComponentResult _rv)")},
    {"MCKey", (PyCFunction)MovieCtlObj_MCKey, 1,
     PyDoc_STR("(SInt8 key, long modifiers) -> (ComponentResult _rv)")},
    {"MCClick", (PyCFunction)MovieCtlObj_MCClick, 1,
     PyDoc_STR("(WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)")},
    {"MCEnableEditing", (PyCFunction)MovieCtlObj_MCEnableEditing, 1,
     PyDoc_STR("(Boolean enabled) -> (ComponentResult _rv)")},
    {"MCIsEditingEnabled", (PyCFunction)MovieCtlObj_MCIsEditingEnabled, 1,
     PyDoc_STR("() -> (long _rv)")},
    {"MCCopy", (PyCFunction)MovieCtlObj_MCCopy, 1,
     PyDoc_STR("() -> (Movie _rv)")},
    {"MCCut", (PyCFunction)MovieCtlObj_MCCut, 1,
     PyDoc_STR("() -> (Movie _rv)")},
    {"MCPaste", (PyCFunction)MovieCtlObj_MCPaste, 1,
     PyDoc_STR("(Movie srcMovie) -> (ComponentResult _rv)")},
    {"MCClear", (PyCFunction)MovieCtlObj_MCClear, 1,
     PyDoc_STR("() -> (ComponentResult _rv)")},
    {"MCUndo", (PyCFunction)MovieCtlObj_MCUndo, 1,
     PyDoc_STR("() -> (ComponentResult _rv)")},
    {"MCPositionController", (PyCFunction)MovieCtlObj_MCPositionController, 1,
     PyDoc_STR("(Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)")},
    {"MCGetControllerInfo", (PyCFunction)MovieCtlObj_MCGetControllerInfo, 1,
     PyDoc_STR("() -> (ComponentResult _rv, long someFlags)")},
    {"MCSetClip", (PyCFunction)MovieCtlObj_MCSetClip, 1,
     PyDoc_STR("(RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)")},
    {"MCGetClip", (PyCFunction)MovieCtlObj_MCGetClip, 1,
     PyDoc_STR("() -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)")},
    {"MCDrawBadge", (PyCFunction)MovieCtlObj_MCDrawBadge, 1,
     PyDoc_STR("(RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)")},
    {"MCSetUpEditMenu", (PyCFunction)MovieCtlObj_MCSetUpEditMenu, 1,
     PyDoc_STR("(long modifiers, MenuHandle mh) -> (ComponentResult _rv)")},
    {"MCGetMenuString", (PyCFunction)MovieCtlObj_MCGetMenuString, 1,
     PyDoc_STR("(long modifiers, short item, Str255 aString) -> (ComponentResult _rv)")},
    {"MCPtInController", (PyCFunction)MovieCtlObj_MCPtInController, 1,
     PyDoc_STR("(Point thePt) -> (ComponentResult _rv, Boolean inController)")},
    {"MCInvalidate", (PyCFunction)MovieCtlObj_MCInvalidate, 1,
     PyDoc_STR("(WindowPtr w, RgnHandle invalidRgn) -> (ComponentResult _rv)")},
    {"MCAdjustCursor", (PyCFunction)MovieCtlObj_MCAdjustCursor, 1,
     PyDoc_STR("(WindowPtr w, Point where, long modifiers) -> (ComponentResult _rv)")},
    {"MCGetInterfaceElement", (PyCFunction)MovieCtlObj_MCGetInterfaceElement, 1,
     PyDoc_STR("(MCInterfaceElement whichElement, void * element) -> (ComponentResult _rv)")},
    {"MCAddMovieSegment", (PyCFunction)MovieCtlObj_MCAddMovieSegment, 1,
     PyDoc_STR("(Movie srcMovie, Boolean scaled) -> (ComponentResult _rv)")},
    {"MCTrimMovieSegment", (PyCFunction)MovieCtlObj_MCTrimMovieSegment, 1,
     PyDoc_STR("() -> (ComponentResult _rv)")},
    {"MCSetIdleManager", (PyCFunction)MovieCtlObj_MCSetIdleManager, 1,
     PyDoc_STR("(IdleManager im) -> (ComponentResult _rv)")},
    {"MCSetControllerCapabilities", (PyCFunction)MovieCtlObj_MCSetControllerCapabilities, 1,
     PyDoc_STR("(long flags, long flagsMask) -> (ComponentResult _rv)")},
    {NULL, NULL, 0}
};

#define MovieCtlObj_getsetlist NULL


#define MovieCtlObj_compare NULL

#define MovieCtlObj_repr NULL

#define MovieCtlObj_hash NULL
#define MovieCtlObj_tp_init 0

#define MovieCtlObj_tp_alloc PyType_GenericAlloc

static PyObject *MovieCtlObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
{
    PyObject *_self;
    MovieController itself;
    char *kw[] = {"itself", 0};

    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, MovieCtlObj_Convert, &itself)) return NULL;
    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    ((MovieControllerObject *)_self)->ob_itself = itself;
    return _self;
}

#define MovieCtlObj_tp_free PyObject_Del


PyTypeObject MovieController_Type = {
    PyObject_HEAD_INIT(NULL)
    0, /*ob_size*/
    "_Qt.MovieController", /*tp_name*/
    sizeof(MovieControllerObject), /*tp_basicsize*/
    0, /*tp_itemsize*/
    /* methods */
    (destructor) MovieCtlObj_dealloc, /*tp_dealloc*/
    0, /*tp_print*/
    (getattrfunc)0, /*tp_getattr*/
    (setattrfunc)0, /*tp_setattr*/
    (cmpfunc) MovieCtlObj_compare, /*tp_compare*/
    (reprfunc) MovieCtlObj_repr, /*tp_repr*/
    (PyNumberMethods *)0, /* tp_as_number */
    (PySequenceMethods *)0, /* tp_as_sequence */
    (PyMappingMethods *)0, /* tp_as_mapping */
    (hashfunc) MovieCtlObj_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*/
    MovieCtlObj_methods, /* tp_methods */
    0, /*tp_members*/
    MovieCtlObj_getsetlist, /*tp_getset*/
    0, /*tp_base*/
    0, /*tp_dict*/
    0, /*tp_descr_get*/
    0, /*tp_descr_set*/
    0, /*tp_dictoffset*/
    MovieCtlObj_tp_init, /* tp_init */
    MovieCtlObj_tp_alloc, /* tp_alloc */
    MovieCtlObj_tp_new, /* tp_new */
    MovieCtlObj_tp_free, /* tp_free */
};

/* ---------------- End object type MovieController ----------------- */


/* ---------------------- Object type TimeBase ---------------------- */

PyTypeObject TimeBase_Type;

#define TimeBaseObj_Check(x) ((x)->ob_type == &TimeBase_Type || PyObject_TypeCheck((x), &TimeBase_Type))

typedef struct TimeBaseObject {
    PyObject_HEAD
    TimeBase ob_itself;
} TimeBaseObject;

PyObject *TimeBaseObj_New(TimeBase itself)
{
    TimeBaseObject *it;
    if (itself == NULL) {
                                    PyErr_SetString(Qt_Error,"Cannot create TimeBase from NULL pointer");
                                    return NULL;
                            }
    it = PyObject_NEW(TimeBaseObject, &TimeBase_Type);
    if (it == NULL) return NULL;
    it->ob_itself = itself;
    return (PyObject *)it;
}

int TimeBaseObj_Convert(PyObject *v, TimeBase *p_itself)
{
    if (v == Py_None)
    {
        *p_itself = NULL;
        return 1;
    }
    if (!TimeBaseObj_Check(v))
    {
        PyErr_SetString(PyExc_TypeError, "TimeBase required");
        return 0;
    }
    *p_itself = ((TimeBaseObject *)v)->ob_itself;
    return 1;
}

static void TimeBaseObj_dealloc(TimeBaseObject *self)
{
    /* Cleanup of self->ob_itself goes here */
    self->ob_type->tp_free((PyObject *)self);
}

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

static PyObject *TimeBaseObj_GetTimeBaseTime(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue _rv;
    TimeScale s;
    TimeRecord tr;
#ifndef GetTimeBaseTime
    PyMac_PRECHECK(GetTimeBaseTime);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &s))
        return NULL;
    _rv = GetTimeBaseTime(_self->ob_itself,
                          s,
                          &tr);
    _res = Py_BuildValue("lO&",
                         _rv,
                         QtTimeRecord_New, &tr);
    return _res;
}

static PyObject *TimeBaseObj_SetTimeBaseTime(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeRecord tr;
#ifndef SetTimeBaseTime
    PyMac_PRECHECK(SetTimeBaseTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          QtTimeRecord_Convert, &tr))
        return NULL;
    SetTimeBaseTime(_self->ob_itself,
                    &tr);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TimeBaseObj_SetTimeBaseValue(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue t;
    TimeScale s;
#ifndef SetTimeBaseValue
    PyMac_PRECHECK(SetTimeBaseValue);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &t,
                          &s))
        return NULL;
    SetTimeBaseValue(_self->ob_itself,
                     t,
                     s);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TimeBaseObj_GetTimeBaseRate(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed _rv;
#ifndef GetTimeBaseRate
    PyMac_PRECHECK(GetTimeBaseRate);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTimeBaseRate(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *TimeBaseObj_SetTimeBaseRate(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed r;
#ifndef SetTimeBaseRate
    PyMac_PRECHECK(SetTimeBaseRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetFixed, &r))
        return NULL;
    SetTimeBaseRate(_self->ob_itself,
                    r);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TimeBaseObj_GetTimeBaseStartTime(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue _rv;
    TimeScale s;
    TimeRecord tr;
#ifndef GetTimeBaseStartTime
    PyMac_PRECHECK(GetTimeBaseStartTime);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &s))
        return NULL;
    _rv = GetTimeBaseStartTime(_self->ob_itself,
                               s,
                               &tr);
    _res = Py_BuildValue("lO&",
                         _rv,
                         QtTimeRecord_New, &tr);
    return _res;
}

static PyObject *TimeBaseObj_SetTimeBaseStartTime(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeRecord tr;
#ifndef SetTimeBaseStartTime
    PyMac_PRECHECK(SetTimeBaseStartTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          QtTimeRecord_Convert, &tr))
        return NULL;
    SetTimeBaseStartTime(_self->ob_itself,
                         &tr);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TimeBaseObj_GetTimeBaseStopTime(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue _rv;
    TimeScale s;
    TimeRecord tr;
#ifndef GetTimeBaseStopTime
    PyMac_PRECHECK(GetTimeBaseStopTime);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &s))
        return NULL;
    _rv = GetTimeBaseStopTime(_self->ob_itself,
                              s,
                              &tr);
    _res = Py_BuildValue("lO&",
                         _rv,
                         QtTimeRecord_New, &tr);
    return _res;
}

static PyObject *TimeBaseObj_SetTimeBaseStopTime(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeRecord tr;
#ifndef SetTimeBaseStopTime
    PyMac_PRECHECK(SetTimeBaseStopTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          QtTimeRecord_Convert, &tr))
        return NULL;
    SetTimeBaseStopTime(_self->ob_itself,
                        &tr);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

static PyObject *TimeBaseObj_SetTimeBaseFlags(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long timeBaseFlags;
#ifndef SetTimeBaseFlags
    PyMac_PRECHECK(SetTimeBaseFlags);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &timeBaseFlags))
        return NULL;
    SetTimeBaseFlags(_self->ob_itself,
                     timeBaseFlags);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TimeBaseObj_SetTimeBaseMasterTimeBase(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeBase master;
    TimeRecord slaveZero;
#ifndef SetTimeBaseMasterTimeBase
    PyMac_PRECHECK(SetTimeBaseMasterTimeBase);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          TimeBaseObj_Convert, &master,
                          QtTimeRecord_Convert, &slaveZero))
        return NULL;
    SetTimeBaseMasterTimeBase(_self->ob_itself,
                              master,
                              &slaveZero);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TimeBaseObj_GetTimeBaseMasterTimeBase(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeBase _rv;
#ifndef GetTimeBaseMasterTimeBase
    PyMac_PRECHECK(GetTimeBaseMasterTimeBase);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTimeBaseMasterTimeBase(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         TimeBaseObj_New, _rv);
    return _res;
}

static PyObject *TimeBaseObj_SetTimeBaseMasterClock(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Component clockMeister;
    TimeRecord slaveZero;
#ifndef SetTimeBaseMasterClock
    PyMac_PRECHECK(SetTimeBaseMasterClock);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpObj_Convert, &clockMeister,
                          QtTimeRecord_Convert, &slaveZero))
        return NULL;
    SetTimeBaseMasterClock(_self->ob_itself,
                           clockMeister,
                           &slaveZero);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TimeBaseObj_GetTimeBaseMasterClock(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentInstance _rv;
#ifndef GetTimeBaseMasterClock
    PyMac_PRECHECK(GetTimeBaseMasterClock);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTimeBaseMasterClock(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         CmpInstObj_New, _rv);
    return _res;
}

static PyObject *TimeBaseObj_GetTimeBaseStatus(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
    TimeRecord unpinnedTime;
#ifndef GetTimeBaseStatus
    PyMac_PRECHECK(GetTimeBaseStatus);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTimeBaseStatus(_self->ob_itself,
                            &unpinnedTime);
    _res = Py_BuildValue("lO&",
                         _rv,
                         QtTimeRecord_New, &unpinnedTime);
    return _res;
}

static PyObject *TimeBaseObj_SetTimeBaseZero(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeRecord zero;
#ifndef SetTimeBaseZero
    PyMac_PRECHECK(SetTimeBaseZero);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          QtTimeRecord_Convert, &zero))
        return NULL;
    SetTimeBaseZero(_self->ob_itself,
                    &zero);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TimeBaseObj_GetTimeBaseEffectiveRate(TimeBaseObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed _rv;
#ifndef GetTimeBaseEffectiveRate
    PyMac_PRECHECK(GetTimeBaseEffectiveRate);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTimeBaseEffectiveRate(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyMethodDef TimeBaseObj_methods[] = {
    {"DisposeTimeBase", (PyCFunction)TimeBaseObj_DisposeTimeBase, 1,
     PyDoc_STR("() -> None")},
    {"GetTimeBaseTime", (PyCFunction)TimeBaseObj_GetTimeBaseTime, 1,
     PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
    {"SetTimeBaseTime", (PyCFunction)TimeBaseObj_SetTimeBaseTime, 1,
     PyDoc_STR("(TimeRecord tr) -> None")},
    {"SetTimeBaseValue", (PyCFunction)TimeBaseObj_SetTimeBaseValue, 1,
     PyDoc_STR("(TimeValue t, TimeScale s) -> None")},
    {"GetTimeBaseRate", (PyCFunction)TimeBaseObj_GetTimeBaseRate, 1,
     PyDoc_STR("() -> (Fixed _rv)")},
    {"SetTimeBaseRate", (PyCFunction)TimeBaseObj_SetTimeBaseRate, 1,
     PyDoc_STR("(Fixed r) -> None")},
    {"GetTimeBaseStartTime", (PyCFunction)TimeBaseObj_GetTimeBaseStartTime, 1,
     PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
    {"SetTimeBaseStartTime", (PyCFunction)TimeBaseObj_SetTimeBaseStartTime, 1,
     PyDoc_STR("(TimeRecord tr) -> None")},
    {"GetTimeBaseStopTime", (PyCFunction)TimeBaseObj_GetTimeBaseStopTime, 1,
     PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
    {"SetTimeBaseStopTime", (PyCFunction)TimeBaseObj_SetTimeBaseStopTime, 1,
     PyDoc_STR("(TimeRecord tr) -> None")},
    {"GetTimeBaseFlags", (PyCFunction)TimeBaseObj_GetTimeBaseFlags, 1,
     PyDoc_STR("() -> (long _rv)")},
    {"SetTimeBaseFlags", (PyCFunction)TimeBaseObj_SetTimeBaseFlags, 1,
     PyDoc_STR("(long timeBaseFlags) -> None")},
    {"SetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_SetTimeBaseMasterTimeBase, 1,
     PyDoc_STR("(TimeBase master, TimeRecord slaveZero) -> None")},
    {"GetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_GetTimeBaseMasterTimeBase, 1,
     PyDoc_STR("() -> (TimeBase _rv)")},
    {"SetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_SetTimeBaseMasterClock, 1,
     PyDoc_STR("(Component clockMeister, TimeRecord slaveZero) -> None")},
    {"GetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_GetTimeBaseMasterClock, 1,
     PyDoc_STR("() -> (ComponentInstance _rv)")},
    {"GetTimeBaseStatus", (PyCFunction)TimeBaseObj_GetTimeBaseStatus, 1,
     PyDoc_STR("() -> (long _rv, TimeRecord unpinnedTime)")},
    {"SetTimeBaseZero", (PyCFunction)TimeBaseObj_SetTimeBaseZero, 1,
     PyDoc_STR("(TimeRecord zero) -> None")},
    {"GetTimeBaseEffectiveRate", (PyCFunction)TimeBaseObj_GetTimeBaseEffectiveRate, 1,
     PyDoc_STR("() -> (Fixed _rv)")},
    {NULL, NULL, 0}
};

#define TimeBaseObj_getsetlist NULL


#define TimeBaseObj_compare NULL

#define TimeBaseObj_repr NULL

#define TimeBaseObj_hash NULL
#define TimeBaseObj_tp_init 0

#define TimeBaseObj_tp_alloc PyType_GenericAlloc

static PyObject *TimeBaseObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
{
    PyObject *_self;
    TimeBase itself;
    char *kw[] = {"itself", 0};

    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, TimeBaseObj_Convert, &itself)) return NULL;
    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    ((TimeBaseObject *)_self)->ob_itself = itself;
    return _self;
}

#define TimeBaseObj_tp_free PyObject_Del


PyTypeObject TimeBase_Type = {
    PyObject_HEAD_INIT(NULL)
    0, /*ob_size*/
    "_Qt.TimeBase", /*tp_name*/
    sizeof(TimeBaseObject), /*tp_basicsize*/
    0, /*tp_itemsize*/
    /* methods */
    (destructor) TimeBaseObj_dealloc, /*tp_dealloc*/
    0, /*tp_print*/
    (getattrfunc)0, /*tp_getattr*/
    (setattrfunc)0, /*tp_setattr*/
    (cmpfunc) TimeBaseObj_compare, /*tp_compare*/
    (reprfunc) TimeBaseObj_repr, /*tp_repr*/
    (PyNumberMethods *)0, /* tp_as_number */
    (PySequenceMethods *)0, /* tp_as_sequence */
    (PyMappingMethods *)0, /* tp_as_mapping */
    (hashfunc) TimeBaseObj_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*/
    TimeBaseObj_methods, /* tp_methods */
    0, /*tp_members*/
    TimeBaseObj_getsetlist, /*tp_getset*/
    0, /*tp_base*/
    0, /*tp_dict*/
    0, /*tp_descr_get*/
    0, /*tp_descr_set*/
    0, /*tp_dictoffset*/
    TimeBaseObj_tp_init, /* tp_init */
    TimeBaseObj_tp_alloc, /* tp_alloc */
    TimeBaseObj_tp_new, /* tp_new */
    TimeBaseObj_tp_free, /* tp_free */
};

/* -------------------- End object type TimeBase -------------------- */


/* ---------------------- Object type UserData ---------------------- */

PyTypeObject UserData_Type;

#define UserDataObj_Check(x) ((x)->ob_type == &UserData_Type || PyObject_TypeCheck((x), &UserData_Type))

typedef struct UserDataObject {
    PyObject_HEAD
    UserData ob_itself;
} UserDataObject;

PyObject *UserDataObj_New(UserData itself)
{
    UserDataObject *it;
    if (itself == NULL) {
                                    PyErr_SetString(Qt_Error,"Cannot create UserData from NULL pointer");
                                    return NULL;
                            }
    it = PyObject_NEW(UserDataObject, &UserData_Type);
    if (it == NULL) return NULL;
    it->ob_itself = itself;
    return (PyObject *)it;
}

int UserDataObj_Convert(PyObject *v, UserData *p_itself)
{
    if (v == Py_None)
    {
        *p_itself = NULL;
        return 1;
    }
    if (!UserDataObj_Check(v))
    {
        PyErr_SetString(PyExc_TypeError, "UserData required");
        return 0;
    }
    *p_itself = ((UserDataObject *)v)->ob_itself;
    return 1;
}

static void UserDataObj_dealloc(UserDataObject *self)
{
    if (self->ob_itself) DisposeUserData(self->ob_itself);
    self->ob_type->tp_free((PyObject *)self);
}

static PyObject *UserDataObj_GetUserData(UserDataObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle data;
    OSType udType;
    long index;
#ifndef GetUserData
    PyMac_PRECHECK(GetUserData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          ResObj_Convert, &data,
                          PyMac_GetOSType, &udType,
                          &index))
        return NULL;
    _err = GetUserData(_self->ob_itself,
                       data,
                       udType,
                       index);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *UserDataObj_AddUserData(UserDataObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle data;
    OSType udType;
#ifndef AddUserData
    PyMac_PRECHECK(AddUserData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &data,
                          PyMac_GetOSType, &udType))
        return NULL;
    _err = AddUserData(_self->ob_itself,
                       data,
                       udType);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *UserDataObj_RemoveUserData(UserDataObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    OSType udType;
    long index;
#ifndef RemoveUserData
    PyMac_PRECHECK(RemoveUserData);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          PyMac_GetOSType, &udType,
                          &index))
        return NULL;
    _err = RemoveUserData(_self->ob_itself,
                          udType,
                          index);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *UserDataObj_CountUserDataType(UserDataObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short _rv;
    OSType udType;
#ifndef CountUserDataType
    PyMac_PRECHECK(CountUserDataType);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetOSType, &udType))
        return NULL;
    _rv = CountUserDataType(_self->ob_itself,
                            udType);
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *UserDataObj_GetNextUserDataType(UserDataObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
    OSType udType;
#ifndef GetNextUserDataType
    PyMac_PRECHECK(GetNextUserDataType);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetOSType, &udType))
        return NULL;
    _rv = GetNextUserDataType(_self->ob_itself,
                              udType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *UserDataObj_AddUserDataText(UserDataObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle data;
    OSType udType;
    long index;
    short itlRegionTag;
#ifndef AddUserDataText
    PyMac_PRECHECK(AddUserDataText);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&lh",
                          ResObj_Convert, &data,
                          PyMac_GetOSType, &udType,
                          &index,
                          &itlRegionTag))
        return NULL;
    _err = AddUserDataText(_self->ob_itself,
                           data,
                           udType,
                           index,
                           itlRegionTag);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *UserDataObj_GetUserDataText(UserDataObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle data;
    OSType udType;
    long index;
    short itlRegionTag;
#ifndef GetUserDataText
    PyMac_PRECHECK(GetUserDataText);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&lh",
                          ResObj_Convert, &data,
                          PyMac_GetOSType, &udType,
                          &index,
                          &itlRegionTag))
        return NULL;
    _err = GetUserDataText(_self->ob_itself,
                           data,
                           udType,
                           index,
                           itlRegionTag);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *UserDataObj_RemoveUserDataText(UserDataObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    OSType udType;
    long index;
    short itlRegionTag;
#ifndef RemoveUserDataText
    PyMac_PRECHECK(RemoveUserDataText);
#endif
    if (!PyArg_ParseTuple(_args, "O&lh",
                          PyMac_GetOSType, &udType,
                          &index,
                          &itlRegionTag))
        return NULL;
    _err = RemoveUserDataText(_self->ob_itself,
                              udType,
                              index,
                              itlRegionTag);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *UserDataObj_PutUserDataIntoHandle(UserDataObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle h;
#ifndef PutUserDataIntoHandle
    PyMac_PRECHECK(PutUserDataIntoHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &h))
        return NULL;
    _err = PutUserDataIntoHandle(_self->ob_itself,
                                 h);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *UserDataObj_CopyUserData(UserDataObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    UserData dstUserData;
    OSType copyRule;
#ifndef CopyUserData
    PyMac_PRECHECK(CopyUserData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          UserDataObj_Convert, &dstUserData,
                          PyMac_GetOSType, &copyRule))
        return NULL;
    _err = CopyUserData(_self->ob_itself,
                        dstUserData,
                        copyRule);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyMethodDef UserDataObj_methods[] = {
    {"GetUserData", (PyCFunction)UserDataObj_GetUserData, 1,
     PyDoc_STR("(Handle data, OSType udType, long index) -> None")},
    {"AddUserData", (PyCFunction)UserDataObj_AddUserData, 1,
     PyDoc_STR("(Handle data, OSType udType) -> None")},
    {"RemoveUserData", (PyCFunction)UserDataObj_RemoveUserData, 1,
     PyDoc_STR("(OSType udType, long index) -> None")},
    {"CountUserDataType", (PyCFunction)UserDataObj_CountUserDataType, 1,
     PyDoc_STR("(OSType udType) -> (short _rv)")},
    {"GetNextUserDataType", (PyCFunction)UserDataObj_GetNextUserDataType, 1,
     PyDoc_STR("(OSType udType) -> (long _rv)")},
    {"AddUserDataText", (PyCFunction)UserDataObj_AddUserDataText, 1,
     PyDoc_STR("(Handle data, OSType udType, long index, short itlRegionTag) -> None")},
    {"GetUserDataText", (PyCFunction)UserDataObj_GetUserDataText, 1,
     PyDoc_STR("(Handle data, OSType udType, long index, short itlRegionTag) -> None")},
    {"RemoveUserDataText", (PyCFunction)UserDataObj_RemoveUserDataText, 1,
     PyDoc_STR("(OSType udType, long index, short itlRegionTag) -> None")},
    {"PutUserDataIntoHandle", (PyCFunction)UserDataObj_PutUserDataIntoHandle, 1,
     PyDoc_STR("(Handle h) -> None")},
    {"CopyUserData", (PyCFunction)UserDataObj_CopyUserData, 1,
     PyDoc_STR("(UserData dstUserData, OSType copyRule) -> None")},
    {NULL, NULL, 0}
};

#define UserDataObj_getsetlist NULL


#define UserDataObj_compare NULL

#define UserDataObj_repr NULL

#define UserDataObj_hash NULL
#define UserDataObj_tp_init 0

#define UserDataObj_tp_alloc PyType_GenericAlloc

static PyObject *UserDataObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
{
    PyObject *_self;
    UserData itself;
    char *kw[] = {"itself", 0};

    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, UserDataObj_Convert, &itself)) return NULL;
    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    ((UserDataObject *)_self)->ob_itself = itself;
    return _self;
}

#define UserDataObj_tp_free PyObject_Del


PyTypeObject UserData_Type = {
    PyObject_HEAD_INIT(NULL)
    0, /*ob_size*/
    "_Qt.UserData", /*tp_name*/
    sizeof(UserDataObject), /*tp_basicsize*/
    0, /*tp_itemsize*/
    /* methods */
    (destructor) UserDataObj_dealloc, /*tp_dealloc*/
    0, /*tp_print*/
    (getattrfunc)0, /*tp_getattr*/
    (setattrfunc)0, /*tp_setattr*/
    (cmpfunc) UserDataObj_compare, /*tp_compare*/
    (reprfunc) UserDataObj_repr, /*tp_repr*/
    (PyNumberMethods *)0, /* tp_as_number */
    (PySequenceMethods *)0, /* tp_as_sequence */
    (PyMappingMethods *)0, /* tp_as_mapping */
    (hashfunc) UserDataObj_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*/
    UserDataObj_methods, /* tp_methods */
    0, /*tp_members*/
    UserDataObj_getsetlist, /*tp_getset*/
    0, /*tp_base*/
    0, /*tp_dict*/
    0, /*tp_descr_get*/
    0, /*tp_descr_set*/
    0, /*tp_dictoffset*/
    UserDataObj_tp_init, /* tp_init */
    UserDataObj_tp_alloc, /* tp_alloc */
    UserDataObj_tp_new, /* tp_new */
    UserDataObj_tp_free, /* tp_free */
};

/* -------------------- End object type UserData -------------------- */


/* ----------------------- Object type Media ------------------------ */

PyTypeObject Media_Type;

#define MediaObj_Check(x) ((x)->ob_type == &Media_Type || PyObject_TypeCheck((x), &Media_Type))

typedef struct MediaObject {
    PyObject_HEAD
    Media ob_itself;
} MediaObject;

PyObject *MediaObj_New(Media itself)
{
    MediaObject *it;
    if (itself == NULL) {
                                    PyErr_SetString(Qt_Error,"Cannot create Media from NULL pointer");
                                    return NULL;
                            }
    it = PyObject_NEW(MediaObject, &Media_Type);
    if (it == NULL) return NULL;
    it->ob_itself = itself;
    return (PyObject *)it;
}

int MediaObj_Convert(PyObject *v, Media *p_itself)
{
    if (v == Py_None)
    {
        *p_itself = NULL;
        return 1;
    }
    if (!MediaObj_Check(v))
    {
        PyErr_SetString(PyExc_TypeError, "Media required");
        return 0;
    }
    *p_itself = ((MediaObject *)v)->ob_itself;
    return 1;
}

static void MediaObj_dealloc(MediaObject *self)
{
    if (self->ob_itself) DisposeTrackMedia(self->ob_itself);
    self->ob_type->tp_free((PyObject *)self);
}

static PyObject *MediaObj_LoadMediaIntoRam(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue time;
    TimeValue duration;
    long flags;
#ifndef LoadMediaIntoRam
    PyMac_PRECHECK(LoadMediaIntoRam);
#endif
    if (!PyArg_ParseTuple(_args, "lll",
                          &time,
                          &duration,
                          &flags))
        return NULL;
    _err = LoadMediaIntoRam(_self->ob_itself,
                            time,
                            duration,
                            flags);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaTrack(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Track _rv;
#ifndef GetMediaTrack
    PyMac_PRECHECK(GetMediaTrack);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMediaTrack(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

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

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

static PyObject *MediaObj_GetMediaTimeScale(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeScale _rv;
#ifndef GetMediaTimeScale
    PyMac_PRECHECK(GetMediaTimeScale);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMediaTimeScale(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MediaObj_SetMediaTimeScale(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeScale timeScale;
#ifndef SetMediaTimeScale
    PyMac_PRECHECK(SetMediaTimeScale);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &timeScale))
        return NULL;
    SetMediaTimeScale(_self->ob_itself,
                      timeScale);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaDuration(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue _rv;
#ifndef GetMediaDuration
    PyMac_PRECHECK(GetMediaDuration);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMediaDuration(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

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

static PyObject *MediaObj_SetMediaLanguage(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short language;
#ifndef SetMediaLanguage
    PyMac_PRECHECK(SetMediaLanguage);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &language))
        return NULL;
    SetMediaLanguage(_self->ob_itself,
                     language);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

static PyObject *MediaObj_SetMediaQuality(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short quality;
#ifndef SetMediaQuality
    PyMac_PRECHECK(SetMediaQuality);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &quality))
        return NULL;
    SetMediaQuality(_self->ob_itself,
                    quality);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaHandlerDescription(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSType mediaType;
    Str255 creatorName;
    OSType creatorManufacturer;
#ifndef GetMediaHandlerDescription
    PyMac_PRECHECK(GetMediaHandlerDescription);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetStr255, creatorName))
        return NULL;
    GetMediaHandlerDescription(_self->ob_itself,
                               &mediaType,
                               creatorName,
                               &creatorManufacturer);
    _res = Py_BuildValue("O&O&",
                         PyMac_BuildOSType, mediaType,
                         PyMac_BuildOSType, creatorManufacturer);
    return _res;
}

static PyObject *MediaObj_GetMediaUserData(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    UserData _rv;
#ifndef GetMediaUserData
    PyMac_PRECHECK(GetMediaUserData);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMediaUserData(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         UserDataObj_New, _rv);
    return _res;
}

static PyObject *MediaObj_GetMediaHandler(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MediaHandler _rv;
#ifndef GetMediaHandler
    PyMac_PRECHECK(GetMediaHandler);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMediaHandler(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         CmpInstObj_New, _rv);
    return _res;
}

static PyObject *MediaObj_SetMediaHandler(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    MediaHandlerComponent mH;
#ifndef SetMediaHandler
    PyMac_PRECHECK(SetMediaHandler);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpObj_Convert, &mH))
        return NULL;
    _err = SetMediaHandler(_self->ob_itself,
                           mH);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_BeginMediaEdits(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
#ifndef BeginMediaEdits
    PyMac_PRECHECK(BeginMediaEdits);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = BeginMediaEdits(_self->ob_itself);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_EndMediaEdits(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
#ifndef EndMediaEdits
    PyMac_PRECHECK(EndMediaEdits);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = EndMediaEdits(_self->ob_itself);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_SetMediaDefaultDataRefIndex(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    short index;
#ifndef SetMediaDefaultDataRefIndex
    PyMac_PRECHECK(SetMediaDefaultDataRefIndex);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &index))
        return NULL;
    _err = SetMediaDefaultDataRefIndex(_self->ob_itself,
                                       index);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaDataHandlerDescription(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short index;
    OSType dhType;
    Str255 creatorName;
    OSType creatorManufacturer;
#ifndef GetMediaDataHandlerDescription
    PyMac_PRECHECK(GetMediaDataHandlerDescription);
#endif
    if (!PyArg_ParseTuple(_args, "hO&",
                          &index,
                          PyMac_GetStr255, creatorName))
        return NULL;
    GetMediaDataHandlerDescription(_self->ob_itself,
                                   index,
                                   &dhType,
                                   creatorName,
                                   &creatorManufacturer);
    _res = Py_BuildValue("O&O&",
                         PyMac_BuildOSType, dhType,
                         PyMac_BuildOSType, creatorManufacturer);
    return _res;
}

static PyObject *MediaObj_GetMediaDataHandler(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    DataHandler _rv;
    short index;
#ifndef GetMediaDataHandler
    PyMac_PRECHECK(GetMediaDataHandler);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &index))
        return NULL;
    _rv = GetMediaDataHandler(_self->ob_itself,
                              index);
    _res = Py_BuildValue("O&",
                         CmpInstObj_New, _rv);
    return _res;
}

static PyObject *MediaObj_SetMediaDataHandler(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    short index;
    DataHandlerComponent dataHandler;
#ifndef SetMediaDataHandler
    PyMac_PRECHECK(SetMediaDataHandler);
#endif
    if (!PyArg_ParseTuple(_args, "hO&",
                          &index,
                          CmpObj_Convert, &dataHandler))
        return NULL;
    _err = SetMediaDataHandler(_self->ob_itself,
                               index,
                               dataHandler);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

static PyObject *MediaObj_GetMediaSampleDescription(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long index;
    SampleDescriptionHandle descH;
#ifndef GetMediaSampleDescription
    PyMac_PRECHECK(GetMediaSampleDescription);
#endif
    if (!PyArg_ParseTuple(_args, "lO&",
                          &index,
                          ResObj_Convert, &descH))
        return NULL;
    GetMediaSampleDescription(_self->ob_itself,
                              index,
                              descH);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_SetMediaSampleDescription(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    long index;
    SampleDescriptionHandle descH;
#ifndef SetMediaSampleDescription
    PyMac_PRECHECK(SetMediaSampleDescription);
#endif
    if (!PyArg_ParseTuple(_args, "lO&",
                          &index,
                          ResObj_Convert, &descH))
        return NULL;
    _err = SetMediaSampleDescription(_self->ob_itself,
                                     index,
                                     descH);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

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

static PyObject *MediaObj_SampleNumToMediaTime(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long logicalSampleNum;
    TimeValue sampleTime;
    TimeValue sampleDuration;
#ifndef SampleNumToMediaTime
    PyMac_PRECHECK(SampleNumToMediaTime);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &logicalSampleNum))
        return NULL;
    SampleNumToMediaTime(_self->ob_itself,
                         logicalSampleNum,
                         &sampleTime,
                         &sampleDuration);
    _res = Py_BuildValue("ll",
                         sampleTime,
                         sampleDuration);
    return _res;
}

static PyObject *MediaObj_MediaTimeToSampleNum(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue time;
    long sampleNum;
    TimeValue sampleTime;
    TimeValue sampleDuration;
#ifndef MediaTimeToSampleNum
    PyMac_PRECHECK(MediaTimeToSampleNum);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &time))
        return NULL;
    MediaTimeToSampleNum(_self->ob_itself,
                         time,
                         &sampleNum,
                         &sampleTime,
                         &sampleDuration);
    _res = Py_BuildValue("lll",
                         sampleNum,
                         sampleTime,
                         sampleDuration);
    return _res;
}

static PyObject *MediaObj_AddMediaSample(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataIn;
    long inOffset;
    unsigned long size;
    TimeValue durationPerSample;
    SampleDescriptionHandle sampleDescriptionH;
    long numberOfSamples;
    short sampleFlags;
    TimeValue sampleTime;
#ifndef AddMediaSample
    PyMac_PRECHECK(AddMediaSample);
#endif
    if (!PyArg_ParseTuple(_args, "O&lllO&lh",
                          ResObj_Convert, &dataIn,
                          &inOffset,
                          &size,
                          &durationPerSample,
                          ResObj_Convert, &sampleDescriptionH,
                          &numberOfSamples,
                          &sampleFlags))
        return NULL;
    _err = AddMediaSample(_self->ob_itself,
                          dataIn,
                          inOffset,
                          size,
                          durationPerSample,
                          sampleDescriptionH,
                          numberOfSamples,
                          sampleFlags,
                          &sampleTime);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         sampleTime);
    return _res;
}

static PyObject *MediaObj_AddMediaSampleReference(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    long dataOffset;
    unsigned long size;
    TimeValue durationPerSample;
    SampleDescriptionHandle sampleDescriptionH;
    long numberOfSamples;
    short sampleFlags;
    TimeValue sampleTime;
#ifndef AddMediaSampleReference
    PyMac_PRECHECK(AddMediaSampleReference);
#endif
    if (!PyArg_ParseTuple(_args, "lllO&lh",
                          &dataOffset,
                          &size,
                          &durationPerSample,
                          ResObj_Convert, &sampleDescriptionH,
                          &numberOfSamples,
                          &sampleFlags))
        return NULL;
    _err = AddMediaSampleReference(_self->ob_itself,
                                   dataOffset,
                                   size,
                                   durationPerSample,
                                   sampleDescriptionH,
                                   numberOfSamples,
                                   sampleFlags,
                                   &sampleTime);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         sampleTime);
    return _res;
}

static PyObject *MediaObj_GetMediaSample(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataOut;
    long maxSizeToGrow;
    long size;
    TimeValue time;
    TimeValue sampleTime;
    TimeValue durationPerSample;
    SampleDescriptionHandle sampleDescriptionH;
    long sampleDescriptionIndex;
    long maxNumberOfSamples;
    long numberOfSamples;
    short sampleFlags;
#ifndef GetMediaSample
    PyMac_PRECHECK(GetMediaSample);
#endif
    if (!PyArg_ParseTuple(_args, "O&llO&l",
                          ResObj_Convert, &dataOut,
                          &maxSizeToGrow,
                          &time,
                          ResObj_Convert, &sampleDescriptionH,
                          &maxNumberOfSamples))
        return NULL;
    _err = GetMediaSample(_self->ob_itself,
                          dataOut,
                          maxSizeToGrow,
                          &size,
                          time,
                          &sampleTime,
                          &durationPerSample,
                          sampleDescriptionH,
                          &sampleDescriptionIndex,
                          maxNumberOfSamples,
                          &numberOfSamples,
                          &sampleFlags);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("lllllh",
                         size,
                         sampleTime,
                         durationPerSample,
                         sampleDescriptionIndex,
                         numberOfSamples,
                         sampleFlags);
    return _res;
}

static PyObject *MediaObj_GetMediaSampleReference(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    long dataOffset;
    long size;
    TimeValue time;
    TimeValue sampleTime;
    TimeValue durationPerSample;
    SampleDescriptionHandle sampleDescriptionH;
    long sampleDescriptionIndex;
    long maxNumberOfSamples;
    long numberOfSamples;
    short sampleFlags;
#ifndef GetMediaSampleReference
    PyMac_PRECHECK(GetMediaSampleReference);
#endif
    if (!PyArg_ParseTuple(_args, "lO&l",
                          &time,
                          ResObj_Convert, &sampleDescriptionH,
                          &maxNumberOfSamples))
        return NULL;
    _err = GetMediaSampleReference(_self->ob_itself,
                                   &dataOffset,
                                   &size,
                                   time,
                                   &sampleTime,
                                   &durationPerSample,
                                   sampleDescriptionH,
                                   &sampleDescriptionIndex,
                                   maxNumberOfSamples,
                                   &numberOfSamples,
                                   &sampleFlags);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("llllllh",
                         dataOffset,
                         size,
                         sampleTime,
                         durationPerSample,
                         sampleDescriptionIndex,
                         numberOfSamples,
                         sampleFlags);
    return _res;
}

static PyObject *MediaObj_SetMediaPreferredChunkSize(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    long maxChunkSize;
#ifndef SetMediaPreferredChunkSize
    PyMac_PRECHECK(SetMediaPreferredChunkSize);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &maxChunkSize))
        return NULL;
    _err = SetMediaPreferredChunkSize(_self->ob_itself,
                                      maxChunkSize);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaPreferredChunkSize(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    long maxChunkSize;
#ifndef GetMediaPreferredChunkSize
    PyMac_PRECHECK(GetMediaPreferredChunkSize);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetMediaPreferredChunkSize(_self->ob_itself,
                                      &maxChunkSize);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         maxChunkSize);
    return _res;
}

static PyObject *MediaObj_SetMediaShadowSync(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    long frameDiffSampleNum;
    long syncSampleNum;
#ifndef SetMediaShadowSync
    PyMac_PRECHECK(SetMediaShadowSync);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &frameDiffSampleNum,
                          &syncSampleNum))
        return NULL;
    _err = SetMediaShadowSync(_self->ob_itself,
                              frameDiffSampleNum,
                              syncSampleNum);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaShadowSync(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    long frameDiffSampleNum;
    long syncSampleNum;
#ifndef GetMediaShadowSync
    PyMac_PRECHECK(GetMediaShadowSync);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &frameDiffSampleNum))
        return NULL;
    _err = GetMediaShadowSync(_self->ob_itself,
                              frameDiffSampleNum,
                              &syncSampleNum);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         syncSampleNum);
    return _res;
}

static PyObject *MediaObj_GetMediaDataSize(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
    TimeValue startTime;
    TimeValue duration;
#ifndef GetMediaDataSize
    PyMac_PRECHECK(GetMediaDataSize);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    _rv = GetMediaDataSize(_self->ob_itself,
                           startTime,
                           duration);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MediaObj_GetMediaDataSize64(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue startTime;
    TimeValue duration;
    wide dataSize;
#ifndef GetMediaDataSize64
    PyMac_PRECHECK(GetMediaDataSize64);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    _err = GetMediaDataSize64(_self->ob_itself,
                              startTime,
                              duration,
                              &dataSize);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         PyMac_Buildwide, dataSize);
    return _res;
}

static PyObject *MediaObj_CopyMediaUserData(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Media dstMedia;
    OSType copyRule;
#ifndef CopyMediaUserData
    PyMac_PRECHECK(CopyMediaUserData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          MediaObj_Convert, &dstMedia,
                          PyMac_GetOSType, &copyRule))
        return NULL;
    _err = CopyMediaUserData(_self->ob_itself,
                             dstMedia,
                             copyRule);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaNextInterestingTime(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short interestingTimeFlags;
    TimeValue time;
    Fixed rate;
    TimeValue interestingTime;
    TimeValue interestingDuration;
#ifndef GetMediaNextInterestingTime
    PyMac_PRECHECK(GetMediaNextInterestingTime);
#endif
    if (!PyArg_ParseTuple(_args, "hlO&",
                          &interestingTimeFlags,
                          &time,
                          PyMac_GetFixed, &rate))
        return NULL;
    GetMediaNextInterestingTime(_self->ob_itself,
                                interestingTimeFlags,
                                time,
                                rate,
                                &interestingTime,
                                &interestingDuration);
    _res = Py_BuildValue("ll",
                         interestingTime,
                         interestingDuration);
    return _res;
}

static PyObject *MediaObj_GetMediaDataRef(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    short index;
    Handle dataRef;
    OSType dataRefType;
    long dataRefAttributes;
#ifndef GetMediaDataRef
    PyMac_PRECHECK(GetMediaDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &index))
        return NULL;
    _err = GetMediaDataRef(_self->ob_itself,
                           index,
                           &dataRef,
                           &dataRefType,
                           &dataRefAttributes);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&O&l",
                         ResObj_New, dataRef,
                         PyMac_BuildOSType, dataRefType,
                         dataRefAttributes);
    return _res;
}

static PyObject *MediaObj_SetMediaDataRef(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    short index;
    Handle dataRef;
    OSType dataRefType;
#ifndef SetMediaDataRef
    PyMac_PRECHECK(SetMediaDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "hO&O&",
                          &index,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _err = SetMediaDataRef(_self->ob_itself,
                           index,
                           dataRef,
                           dataRefType);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_SetMediaDataRefAttributes(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    short index;
    long dataRefAttributes;
#ifndef SetMediaDataRefAttributes
    PyMac_PRECHECK(SetMediaDataRefAttributes);
#endif
    if (!PyArg_ParseTuple(_args, "hl",
                          &index,
                          &dataRefAttributes))
        return NULL;
    _err = SetMediaDataRefAttributes(_self->ob_itself,
                                     index,
                                     dataRefAttributes);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_AddMediaDataRef(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    short index;
    Handle dataRef;
    OSType dataRefType;
#ifndef AddMediaDataRef
    PyMac_PRECHECK(AddMediaDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _err = AddMediaDataRef(_self->ob_itself,
                           &index,
                           dataRef,
                           dataRefType);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         index);
    return _res;
}

static PyObject *MediaObj_GetMediaDataRefCount(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    short count;
#ifndef GetMediaDataRefCount
    PyMac_PRECHECK(GetMediaDataRefCount);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetMediaDataRefCount(_self->ob_itself,
                                &count);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         count);
    return _res;
}

static PyObject *MediaObj_SetMediaPlayHints(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long flags;
    long flagsMask;
#ifndef SetMediaPlayHints
    PyMac_PRECHECK(SetMediaPlayHints);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &flags,
                          &flagsMask))
        return NULL;
    SetMediaPlayHints(_self->ob_itself,
                      flags,
                      flagsMask);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaPlayHints(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long flags;
#ifndef GetMediaPlayHints
    PyMac_PRECHECK(GetMediaPlayHints);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetMediaPlayHints(_self->ob_itself,
                      &flags);
    _res = Py_BuildValue("l",
                         flags);
    return _res;
}

static PyObject *MediaObj_GetMediaNextInterestingTimeOnly(MediaObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short interestingTimeFlags;
    TimeValue time;
    Fixed rate;
    TimeValue interestingTime;
#ifndef GetMediaNextInterestingTimeOnly
    PyMac_PRECHECK(GetMediaNextInterestingTimeOnly);
#endif
    if (!PyArg_ParseTuple(_args, "hlO&",
                          &interestingTimeFlags,
                          &time,
                          PyMac_GetFixed, &rate))
        return NULL;
    GetMediaNextInterestingTimeOnly(_self->ob_itself,
                                    interestingTimeFlags,
                                    time,
                                    rate,
                                    &interestingTime);
    _res = Py_BuildValue("l",
                         interestingTime);
    return _res;
}

static PyMethodDef MediaObj_methods[] = {
    {"LoadMediaIntoRam", (PyCFunction)MediaObj_LoadMediaIntoRam, 1,
     PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")},
    {"GetMediaTrack", (PyCFunction)MediaObj_GetMediaTrack, 1,
     PyDoc_STR("() -> (Track _rv)")},
    {"GetMediaCreationTime", (PyCFunction)MediaObj_GetMediaCreationTime, 1,
     PyDoc_STR("() -> (unsigned long _rv)")},
    {"GetMediaModificationTime", (PyCFunction)MediaObj_GetMediaModificationTime, 1,
     PyDoc_STR("() -> (unsigned long _rv)")},
    {"GetMediaTimeScale", (PyCFunction)MediaObj_GetMediaTimeScale, 1,
     PyDoc_STR("() -> (TimeScale _rv)")},
    {"SetMediaTimeScale", (PyCFunction)MediaObj_SetMediaTimeScale, 1,
     PyDoc_STR("(TimeScale timeScale) -> None")},
    {"GetMediaDuration", (PyCFunction)MediaObj_GetMediaDuration, 1,
     PyDoc_STR("() -> (TimeValue _rv)")},
    {"GetMediaLanguage", (PyCFunction)MediaObj_GetMediaLanguage, 1,
     PyDoc_STR("() -> (short _rv)")},
    {"SetMediaLanguage", (PyCFunction)MediaObj_SetMediaLanguage, 1,
     PyDoc_STR("(short language) -> None")},
    {"GetMediaQuality", (PyCFunction)MediaObj_GetMediaQuality, 1,
     PyDoc_STR("() -> (short _rv)")},
    {"SetMediaQuality", (PyCFunction)MediaObj_SetMediaQuality, 1,
     PyDoc_STR("(short quality) -> None")},
    {"GetMediaHandlerDescription", (PyCFunction)MediaObj_GetMediaHandlerDescription, 1,
     PyDoc_STR("(Str255 creatorName) -> (OSType mediaType, OSType creatorManufacturer)")},
    {"GetMediaUserData", (PyCFunction)MediaObj_GetMediaUserData, 1,
     PyDoc_STR("() -> (UserData _rv)")},
    {"GetMediaHandler", (PyCFunction)MediaObj_GetMediaHandler, 1,
     PyDoc_STR("() -> (MediaHandler _rv)")},
    {"SetMediaHandler", (PyCFunction)MediaObj_SetMediaHandler, 1,
     PyDoc_STR("(MediaHandlerComponent mH) -> None")},
    {"BeginMediaEdits", (PyCFunction)MediaObj_BeginMediaEdits, 1,
     PyDoc_STR("() -> None")},
    {"EndMediaEdits", (PyCFunction)MediaObj_EndMediaEdits, 1,
     PyDoc_STR("() -> None")},
    {"SetMediaDefaultDataRefIndex", (PyCFunction)MediaObj_SetMediaDefaultDataRefIndex, 1,
     PyDoc_STR("(short index) -> None")},
    {"GetMediaDataHandlerDescription", (PyCFunction)MediaObj_GetMediaDataHandlerDescription, 1,
     PyDoc_STR("(short index, Str255 creatorName) -> (OSType dhType, OSType creatorManufacturer)")},
    {"GetMediaDataHandler", (PyCFunction)MediaObj_GetMediaDataHandler, 1,
     PyDoc_STR("(short index) -> (DataHandler _rv)")},
    {"SetMediaDataHandler", (PyCFunction)MediaObj_SetMediaDataHandler, 1,
     PyDoc_STR("(short index, DataHandlerComponent dataHandler) -> None")},
    {"GetMediaSampleDescriptionCount", (PyCFunction)MediaObj_GetMediaSampleDescriptionCount, 1,
     PyDoc_STR("() -> (long _rv)")},
    {"GetMediaSampleDescription", (PyCFunction)MediaObj_GetMediaSampleDescription, 1,
     PyDoc_STR("(long index, SampleDescriptionHandle descH) -> None")},
    {"SetMediaSampleDescription", (PyCFunction)MediaObj_SetMediaSampleDescription, 1,
     PyDoc_STR("(long index, SampleDescriptionHandle descH) -> None")},
    {"GetMediaSampleCount", (PyCFunction)MediaObj_GetMediaSampleCount, 1,
     PyDoc_STR("() -> (long _rv)")},
    {"GetMediaSyncSampleCount", (PyCFunction)MediaObj_GetMediaSyncSampleCount, 1,
     PyDoc_STR("() -> (long _rv)")},
    {"SampleNumToMediaTime", (PyCFunction)MediaObj_SampleNumToMediaTime, 1,
     PyDoc_STR("(long logicalSampleNum) -> (TimeValue sampleTime, TimeValue sampleDuration)")},
    {"MediaTimeToSampleNum", (PyCFunction)MediaObj_MediaTimeToSampleNum, 1,
     PyDoc_STR("(TimeValue time) -> (long sampleNum, TimeValue sampleTime, TimeValue sampleDuration)")},
    {"AddMediaSample", (PyCFunction)MediaObj_AddMediaSample, 1,
     PyDoc_STR("(Handle dataIn, long inOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)")},
    {"AddMediaSampleReference", (PyCFunction)MediaObj_AddMediaSampleReference, 1,
     PyDoc_STR("(long dataOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)")},
    {"GetMediaSample", (PyCFunction)MediaObj_GetMediaSample, 1,
     PyDoc_STR("(Handle dataOut, long maxSizeToGrow, TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)")},
    {"GetMediaSampleReference", (PyCFunction)MediaObj_GetMediaSampleReference, 1,
     PyDoc_STR("(TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long dataOffset, long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)")},
    {"SetMediaPreferredChunkSize", (PyCFunction)MediaObj_SetMediaPreferredChunkSize, 1,
     PyDoc_STR("(long maxChunkSize) -> None")},
    {"GetMediaPreferredChunkSize", (PyCFunction)MediaObj_GetMediaPreferredChunkSize, 1,
     PyDoc_STR("() -> (long maxChunkSize)")},
    {"SetMediaShadowSync", (PyCFunction)MediaObj_SetMediaShadowSync, 1,
     PyDoc_STR("(long frameDiffSampleNum, long syncSampleNum) -> None")},
    {"GetMediaShadowSync", (PyCFunction)MediaObj_GetMediaShadowSync, 1,
     PyDoc_STR("(long frameDiffSampleNum) -> (long syncSampleNum)")},
    {"GetMediaDataSize", (PyCFunction)MediaObj_GetMediaDataSize, 1,
     PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")},
    {"GetMediaDataSize64", (PyCFunction)MediaObj_GetMediaDataSize64, 1,
     PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")},
    {"CopyMediaUserData", (PyCFunction)MediaObj_CopyMediaUserData, 1,
     PyDoc_STR("(Media dstMedia, OSType copyRule) -> None")},
    {"GetMediaNextInterestingTime", (PyCFunction)MediaObj_GetMediaNextInterestingTime, 1,
     PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
    {"GetMediaDataRef", (PyCFunction)MediaObj_GetMediaDataRef, 1,
     PyDoc_STR("(short index) -> (Handle dataRef, OSType dataRefType, long dataRefAttributes)")},
    {"SetMediaDataRef", (PyCFunction)MediaObj_SetMediaDataRef, 1,
     PyDoc_STR("(short index, Handle dataRef, OSType dataRefType) -> None")},
    {"SetMediaDataRefAttributes", (PyCFunction)MediaObj_SetMediaDataRefAttributes, 1,
     PyDoc_STR("(short index, long dataRefAttributes) -> None")},
    {"AddMediaDataRef", (PyCFunction)MediaObj_AddMediaDataRef, 1,
     PyDoc_STR("(Handle dataRef, OSType dataRefType) -> (short index)")},
    {"GetMediaDataRefCount", (PyCFunction)MediaObj_GetMediaDataRefCount, 1,
     PyDoc_STR("() -> (short count)")},
    {"SetMediaPlayHints", (PyCFunction)MediaObj_SetMediaPlayHints, 1,
     PyDoc_STR("(long flags, long flagsMask) -> None")},
    {"GetMediaPlayHints", (PyCFunction)MediaObj_GetMediaPlayHints, 1,
     PyDoc_STR("() -> (long flags)")},
    {"GetMediaNextInterestingTimeOnly", (PyCFunction)MediaObj_GetMediaNextInterestingTimeOnly, 1,
     PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime)")},
    {NULL, NULL, 0}
};

#define MediaObj_getsetlist NULL


#define MediaObj_compare NULL

#define MediaObj_repr NULL

#define MediaObj_hash NULL
#define MediaObj_tp_init 0

#define MediaObj_tp_alloc PyType_GenericAlloc

static PyObject *MediaObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
{
    PyObject *_self;
    Media itself;
    char *kw[] = {"itself", 0};

    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, MediaObj_Convert, &itself)) return NULL;
    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    ((MediaObject *)_self)->ob_itself = itself;
    return _self;
}

#define MediaObj_tp_free PyObject_Del


PyTypeObject Media_Type = {
    PyObject_HEAD_INIT(NULL)
    0, /*ob_size*/
    "_Qt.Media", /*tp_name*/
    sizeof(MediaObject), /*tp_basicsize*/
    0, /*tp_itemsize*/
    /* methods */
    (destructor) MediaObj_dealloc, /*tp_dealloc*/
    0, /*tp_print*/
    (getattrfunc)0, /*tp_getattr*/
    (setattrfunc)0, /*tp_setattr*/
    (cmpfunc) MediaObj_compare, /*tp_compare*/
    (reprfunc) MediaObj_repr, /*tp_repr*/
    (PyNumberMethods *)0, /* tp_as_number */
    (PySequenceMethods *)0, /* tp_as_sequence */
    (PyMappingMethods *)0, /* tp_as_mapping */
    (hashfunc) MediaObj_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*/
    MediaObj_methods, /* tp_methods */
    0, /*tp_members*/
    MediaObj_getsetlist, /*tp_getset*/
    0, /*tp_base*/
    0, /*tp_dict*/
    0, /*tp_descr_get*/
    0, /*tp_descr_set*/
    0, /*tp_dictoffset*/
    MediaObj_tp_init, /* tp_init */
    MediaObj_tp_alloc, /* tp_alloc */
    MediaObj_tp_new, /* tp_new */
    MediaObj_tp_free, /* tp_free */
};

/* --------------------- End object type Media ---------------------- */


/* ----------------------- Object type Track ------------------------ */

PyTypeObject Track_Type;

#define TrackObj_Check(x) ((x)->ob_type == &Track_Type || PyObject_TypeCheck((x), &Track_Type))

typedef struct TrackObject {
    PyObject_HEAD
    Track ob_itself;
} TrackObject;

PyObject *TrackObj_New(Track itself)
{
    TrackObject *it;
    if (itself == NULL) {
                                    PyErr_SetString(Qt_Error,"Cannot create Track from NULL pointer");
                                    return NULL;
                            }
    it = PyObject_NEW(TrackObject, &Track_Type);
    if (it == NULL) return NULL;
    it->ob_itself = itself;
    return (PyObject *)it;
}

int TrackObj_Convert(PyObject *v, Track *p_itself)
{
    if (v == Py_None)
    {
        *p_itself = NULL;
        return 1;
    }
    if (!TrackObj_Check(v))
    {
        PyErr_SetString(PyExc_TypeError, "Track required");
        return 0;
    }
    *p_itself = ((TrackObject *)v)->ob_itself;
    return 1;
}

static void TrackObj_dealloc(TrackObject *self)
{
    if (self->ob_itself) DisposeMovieTrack(self->ob_itself);
    self->ob_type->tp_free((PyObject *)self);
}

static PyObject *TrackObj_LoadTrackIntoRam(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue time;
    TimeValue duration;
    long flags;
#ifndef LoadTrackIntoRam
    PyMac_PRECHECK(LoadTrackIntoRam);
#endif
    if (!PyArg_ParseTuple(_args, "lll",
                          &time,
                          &duration,
                          &flags))
        return NULL;
    _err = LoadTrackIntoRam(_self->ob_itself,
                            time,
                            duration,
                            flags);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackPict(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    PicHandle _rv;
    TimeValue time;
#ifndef GetTrackPict
    PyMac_PRECHECK(GetTrackPict);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &time))
        return NULL;
    _rv = GetTrackPict(_self->ob_itself,
                       time);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackClipRgn(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    RgnHandle _rv;
#ifndef GetTrackClipRgn
    PyMac_PRECHECK(GetTrackClipRgn);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackClipRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

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

static PyObject *TrackObj_GetTrackDisplayBoundsRgn(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    RgnHandle _rv;
#ifndef GetTrackDisplayBoundsRgn
    PyMac_PRECHECK(GetTrackDisplayBoundsRgn);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackDisplayBoundsRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackMovieBoundsRgn(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    RgnHandle _rv;
#ifndef GetTrackMovieBoundsRgn
    PyMac_PRECHECK(GetTrackMovieBoundsRgn);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackMovieBoundsRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackBoundsRgn(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    RgnHandle _rv;
#ifndef GetTrackBoundsRgn
    PyMac_PRECHECK(GetTrackBoundsRgn);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackBoundsRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackMatte(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    PixMapHandle _rv;
#ifndef GetTrackMatte
    PyMac_PRECHECK(GetTrackMatte);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackMatte(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_SetTrackMatte(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    PixMapHandle theMatte;
#ifndef SetTrackMatte
    PyMac_PRECHECK(SetTrackMatte);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &theMatte))
        return NULL;
    SetTrackMatte(_self->ob_itself,
                  theMatte);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

static PyObject *TrackObj_GetTrackMovie(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Movie _rv;
#ifndef GetTrackMovie
    PyMac_PRECHECK(GetTrackMovie);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackMovie(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

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

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

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

static PyObject *TrackObj_SetTrackEnabled(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean isEnabled;
#ifndef SetTrackEnabled
    PyMac_PRECHECK(SetTrackEnabled);
#endif
    if (!PyArg_ParseTuple(_args, "b",
                          &isEnabled))
        return NULL;
    SetTrackEnabled(_self->ob_itself,
                    isEnabled);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

static PyObject *TrackObj_SetTrackUsage(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long usage;
#ifndef SetTrackUsage
    PyMac_PRECHECK(SetTrackUsage);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &usage))
        return NULL;
    SetTrackUsage(_self->ob_itself,
                  usage);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackDuration(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue _rv;
#ifndef GetTrackDuration
    PyMac_PRECHECK(GetTrackDuration);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackDuration(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackOffset(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue _rv;
#ifndef GetTrackOffset
    PyMac_PRECHECK(GetTrackOffset);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackOffset(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *TrackObj_SetTrackOffset(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue movieOffsetTime;
#ifndef SetTrackOffset
    PyMac_PRECHECK(SetTrackOffset);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &movieOffsetTime))
        return NULL;
    SetTrackOffset(_self->ob_itself,
                   movieOffsetTime);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

static PyObject *TrackObj_SetTrackLayer(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short layer;
#ifndef SetTrackLayer
    PyMac_PRECHECK(SetTrackLayer);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &layer))
        return NULL;
    SetTrackLayer(_self->ob_itself,
                  layer);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackAlternate(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Track _rv;
#ifndef GetTrackAlternate
    PyMac_PRECHECK(GetTrackAlternate);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackAlternate(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_SetTrackAlternate(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Track alternateT;
#ifndef SetTrackAlternate
    PyMac_PRECHECK(SetTrackAlternate);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          TrackObj_Convert, &alternateT))
        return NULL;
    SetTrackAlternate(_self->ob_itself,
                      alternateT);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

static PyObject *TrackObj_SetTrackVolume(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short volume;
#ifndef SetTrackVolume
    PyMac_PRECHECK(SetTrackVolume);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &volume))
        return NULL;
    SetTrackVolume(_self->ob_itself,
                   volume);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackDimensions(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed width;
    Fixed height;
#ifndef GetTrackDimensions
    PyMac_PRECHECK(GetTrackDimensions);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetTrackDimensions(_self->ob_itself,
                       &width,
                       &height);
    _res = Py_BuildValue("O&O&",
                         PyMac_BuildFixed, width,
                         PyMac_BuildFixed, height);
    return _res;
}

static PyObject *TrackObj_SetTrackDimensions(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed width;
    Fixed height;
#ifndef SetTrackDimensions
    PyMac_PRECHECK(SetTrackDimensions);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          PyMac_GetFixed, &width,
                          PyMac_GetFixed, &height))
        return NULL;
    SetTrackDimensions(_self->ob_itself,
                       width,
                       height);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackUserData(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    UserData _rv;
#ifndef GetTrackUserData
    PyMac_PRECHECK(GetTrackUserData);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackUserData(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         UserDataObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackSoundLocalizationSettings(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle settings;
#ifndef GetTrackSoundLocalizationSettings
    PyMac_PRECHECK(GetTrackSoundLocalizationSettings);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetTrackSoundLocalizationSettings(_self->ob_itself,
                                             &settings);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         ResObj_New, settings);
    return _res;
}

static PyObject *TrackObj_SetTrackSoundLocalizationSettings(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle settings;
#ifndef SetTrackSoundLocalizationSettings
    PyMac_PRECHECK(SetTrackSoundLocalizationSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &settings))
        return NULL;
    _err = SetTrackSoundLocalizationSettings(_self->ob_itself,
                                             settings);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_NewTrackMedia(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Media _rv;
    OSType mediaType;
    TimeScale timeScale;
    Handle dataRef;
    OSType dataRefType;
#ifndef NewTrackMedia
    PyMac_PRECHECK(NewTrackMedia);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&O&",
                          PyMac_GetOSType, &mediaType,
                          &timeScale,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _rv = NewTrackMedia(_self->ob_itself,
                        mediaType,
                        timeScale,
                        dataRef,
                        dataRefType);
    _res = Py_BuildValue("O&",
                         MediaObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackMedia(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Media _rv;
#ifndef GetTrackMedia
    PyMac_PRECHECK(GetTrackMedia);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackMedia(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         MediaObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_InsertMediaIntoTrack(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue trackStart;
    TimeValue mediaTime;
    TimeValue mediaDuration;
    Fixed mediaRate;
#ifndef InsertMediaIntoTrack
    PyMac_PRECHECK(InsertMediaIntoTrack);
#endif
    if (!PyArg_ParseTuple(_args, "lllO&",
                          &trackStart,
                          &mediaTime,
                          &mediaDuration,
                          PyMac_GetFixed, &mediaRate))
        return NULL;
    _err = InsertMediaIntoTrack(_self->ob_itself,
                                trackStart,
                                mediaTime,
                                mediaDuration,
                                mediaRate);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_InsertTrackSegment(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Track dstTrack;
    TimeValue srcIn;
    TimeValue srcDuration;
    TimeValue dstIn;
#ifndef InsertTrackSegment
    PyMac_PRECHECK(InsertTrackSegment);
#endif
    if (!PyArg_ParseTuple(_args, "O&lll",
                          TrackObj_Convert, &dstTrack,
                          &srcIn,
                          &srcDuration,
                          &dstIn))
        return NULL;
    _err = InsertTrackSegment(_self->ob_itself,
                              dstTrack,
                              srcIn,
                              srcDuration,
                              dstIn);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_InsertEmptyTrackSegment(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue dstIn;
    TimeValue dstDuration;
#ifndef InsertEmptyTrackSegment
    PyMac_PRECHECK(InsertEmptyTrackSegment);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &dstIn,
                          &dstDuration))
        return NULL;
    _err = InsertEmptyTrackSegment(_self->ob_itself,
                                   dstIn,
                                   dstDuration);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_DeleteTrackSegment(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue startTime;
    TimeValue duration;
#ifndef DeleteTrackSegment
    PyMac_PRECHECK(DeleteTrackSegment);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    _err = DeleteTrackSegment(_self->ob_itself,
                              startTime,
                              duration);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_ScaleTrackSegment(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue startTime;
    TimeValue oldDuration;
    TimeValue newDuration;
#ifndef ScaleTrackSegment
    PyMac_PRECHECK(ScaleTrackSegment);
#endif
    if (!PyArg_ParseTuple(_args, "lll",
                          &startTime,
                          &oldDuration,
                          &newDuration))
        return NULL;
    _err = ScaleTrackSegment(_self->ob_itself,
                             startTime,
                             oldDuration,
                             newDuration);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_IsScrapMovie(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Component _rv;
#ifndef IsScrapMovie
    PyMac_PRECHECK(IsScrapMovie);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = IsScrapMovie(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         CmpObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_CopyTrackSettings(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Track dstTrack;
#ifndef CopyTrackSettings
    PyMac_PRECHECK(CopyTrackSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          TrackObj_Convert, &dstTrack))
        return NULL;
    _err = CopyTrackSettings(_self->ob_itself,
                             dstTrack);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_AddEmptyTrackToMovie(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie dstMovie;
    Handle dataRef;
    OSType dataRefType;
    Track dstTrack;
#ifndef AddEmptyTrackToMovie
    PyMac_PRECHECK(AddEmptyTrackToMovie);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          MovieObj_Convert, &dstMovie,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _err = AddEmptyTrackToMovie(_self->ob_itself,
                                dstMovie,
                                dataRef,
                                dataRefType,
                                &dstTrack);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         TrackObj_New, dstTrack);
    return _res;
}

static PyObject *TrackObj_AddClonedTrackToMovie(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie dstMovie;
    long flags;
    Track dstTrack;
#ifndef AddClonedTrackToMovie
    PyMac_PRECHECK(AddClonedTrackToMovie);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          MovieObj_Convert, &dstMovie,
                          &flags))
        return NULL;
    _err = AddClonedTrackToMovie(_self->ob_itself,
                                 dstMovie,
                                 flags,
                                 &dstTrack);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         TrackObj_New, dstTrack);
    return _res;
}

static PyObject *TrackObj_AddTrackReference(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Track refTrack;
    OSType refType;
    long addedIndex;
#ifndef AddTrackReference
    PyMac_PRECHECK(AddTrackReference);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          TrackObj_Convert, &refTrack,
                          PyMac_GetOSType, &refType))
        return NULL;
    _err = AddTrackReference(_self->ob_itself,
                             refTrack,
                             refType,
                             &addedIndex);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         addedIndex);
    return _res;
}

static PyObject *TrackObj_DeleteTrackReference(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    OSType refType;
    long index;
#ifndef DeleteTrackReference
    PyMac_PRECHECK(DeleteTrackReference);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          PyMac_GetOSType, &refType,
                          &index))
        return NULL;
    _err = DeleteTrackReference(_self->ob_itself,
                                refType,
                                index);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_SetTrackReference(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Track refTrack;
    OSType refType;
    long index;
#ifndef SetTrackReference
    PyMac_PRECHECK(SetTrackReference);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          TrackObj_Convert, &refTrack,
                          PyMac_GetOSType, &refType,
                          &index))
        return NULL;
    _err = SetTrackReference(_self->ob_itself,
                             refTrack,
                             refType,
                             index);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackReference(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Track _rv;
    OSType refType;
    long index;
#ifndef GetTrackReference
    PyMac_PRECHECK(GetTrackReference);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          PyMac_GetOSType, &refType,
                          &index))
        return NULL;
    _rv = GetTrackReference(_self->ob_itself,
                            refType,
                            index);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetNextTrackReferenceType(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSType _rv;
    OSType refType;
#ifndef GetNextTrackReferenceType
    PyMac_PRECHECK(GetNextTrackReferenceType);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetOSType, &refType))
        return NULL;
    _rv = GetNextTrackReferenceType(_self->ob_itself,
                                    refType);
    _res = Py_BuildValue("O&",
                         PyMac_BuildOSType, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackReferenceCount(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
    OSType refType;
#ifndef GetTrackReferenceCount
    PyMac_PRECHECK(GetTrackReferenceCount);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetOSType, &refType))
        return NULL;
    _rv = GetTrackReferenceCount(_self->ob_itself,
                                 refType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackEditRate(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed _rv;
    TimeValue atTime;
#ifndef GetTrackEditRate
    PyMac_PRECHECK(GetTrackEditRate);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &atTime))
        return NULL;
    _rv = GetTrackEditRate(_self->ob_itself,
                           atTime);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackDataSize(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
    TimeValue startTime;
    TimeValue duration;
#ifndef GetTrackDataSize
    PyMac_PRECHECK(GetTrackDataSize);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    _rv = GetTrackDataSize(_self->ob_itself,
                           startTime,
                           duration);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackDataSize64(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue startTime;
    TimeValue duration;
    wide dataSize;
#ifndef GetTrackDataSize64
    PyMac_PRECHECK(GetTrackDataSize64);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    _err = GetTrackDataSize64(_self->ob_itself,
                              startTime,
                              duration,
                              &dataSize);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         PyMac_Buildwide, dataSize);
    return _res;
}

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

static PyObject *TrackObj_CopyTrackUserData(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Track dstTrack;
    OSType copyRule;
#ifndef CopyTrackUserData
    PyMac_PRECHECK(CopyTrackUserData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          TrackObj_Convert, &dstTrack,
                          PyMac_GetOSType, &copyRule))
        return NULL;
    _err = CopyTrackUserData(_self->ob_itself,
                             dstTrack,
                             copyRule);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackNextInterestingTime(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short interestingTimeFlags;
    TimeValue time;
    Fixed rate;
    TimeValue interestingTime;
    TimeValue interestingDuration;
#ifndef GetTrackNextInterestingTime
    PyMac_PRECHECK(GetTrackNextInterestingTime);
#endif
    if (!PyArg_ParseTuple(_args, "hlO&",
                          &interestingTimeFlags,
                          &time,
                          PyMac_GetFixed, &rate))
        return NULL;
    GetTrackNextInterestingTime(_self->ob_itself,
                                interestingTimeFlags,
                                time,
                                rate,
                                &interestingTime,
                                &interestingDuration);
    _res = Py_BuildValue("ll",
                         interestingTime,
                         interestingDuration);
    return _res;
}

static PyObject *TrackObj_GetTrackSegmentDisplayBoundsRgn(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    TimeValue time;
    TimeValue duration;
#ifndef GetTrackSegmentDisplayBoundsRgn
    PyMac_PRECHECK(GetTrackSegmentDisplayBoundsRgn);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &time,
                          &duration))
        return NULL;
    _rv = GetTrackSegmentDisplayBoundsRgn(_self->ob_itself,
                                          time,
                                          duration);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackStatus(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
#ifndef GetTrackStatus
    PyMac_PRECHECK(GetTrackStatus);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackStatus(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *TrackObj_SetTrackLoadSettings(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue preloadTime;
    TimeValue preloadDuration;
    long preloadFlags;
    long defaultHints;
#ifndef SetTrackLoadSettings
    PyMac_PRECHECK(SetTrackLoadSettings);
#endif
    if (!PyArg_ParseTuple(_args, "llll",
                          &preloadTime,
                          &preloadDuration,
                          &preloadFlags,
                          &defaultHints))
        return NULL;
    SetTrackLoadSettings(_self->ob_itself,
                         preloadTime,
                         preloadDuration,
                         preloadFlags,
                         defaultHints);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackLoadSettings(TrackObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue preloadTime;
    TimeValue preloadDuration;
    long preloadFlags;
    long defaultHints;
#ifndef GetTrackLoadSettings
    PyMac_PRECHECK(GetTrackLoadSettings);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetTrackLoadSettings(_self->ob_itself,
                         &preloadTime,
                         &preloadDuration,
                         &preloadFlags,
                         &defaultHints);
    _res = Py_BuildValue("llll",
                         preloadTime,
                         preloadDuration,
                         preloadFlags,
                         defaultHints);
    return _res;
}

static PyMethodDef TrackObj_methods[] = {
    {"LoadTrackIntoRam", (PyCFunction)TrackObj_LoadTrackIntoRam, 1,
     PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")},
    {"GetTrackPict", (PyCFunction)TrackObj_GetTrackPict, 1,
     PyDoc_STR("(TimeValue time) -> (PicHandle _rv)")},
    {"GetTrackClipRgn", (PyCFunction)TrackObj_GetTrackClipRgn, 1,
     PyDoc_STR("() -> (RgnHandle _rv)")},
    {"SetTrackClipRgn", (PyCFunction)TrackObj_SetTrackClipRgn, 1,
     PyDoc_STR("(RgnHandle theClip) -> None")},
    {"GetTrackDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackDisplayBoundsRgn, 1,
     PyDoc_STR("() -> (RgnHandle _rv)")},
    {"GetTrackMovieBoundsRgn", (PyCFunction)TrackObj_GetTrackMovieBoundsRgn, 1,
     PyDoc_STR("() -> (RgnHandle _rv)")},
    {"GetTrackBoundsRgn", (PyCFunction)TrackObj_GetTrackBoundsRgn, 1,
     PyDoc_STR("() -> (RgnHandle _rv)")},
    {"GetTrackMatte", (PyCFunction)TrackObj_GetTrackMatte, 1,
     PyDoc_STR("() -> (PixMapHandle _rv)")},
    {"SetTrackMatte", (PyCFunction)TrackObj_SetTrackMatte, 1,
     PyDoc_STR("(PixMapHandle theMatte) -> None")},
    {"GetTrackID", (PyCFunction)TrackObj_GetTrackID, 1,
     PyDoc_STR("() -> (long _rv)")},
    {"GetTrackMovie", (PyCFunction)TrackObj_GetTrackMovie, 1,
     PyDoc_STR("() -> (Movie _rv)")},
    {"GetTrackCreationTime", (PyCFunction)TrackObj_GetTrackCreationTime, 1,
     PyDoc_STR("() -> (unsigned long _rv)")},
    {"GetTrackModificationTime", (PyCFunction)TrackObj_GetTrackModificationTime, 1,
     PyDoc_STR("() -> (unsigned long _rv)")},
    {"GetTrackEnabled", (PyCFunction)TrackObj_GetTrackEnabled, 1,
     PyDoc_STR("() -> (Boolean _rv)")},
    {"SetTrackEnabled", (PyCFunction)TrackObj_SetTrackEnabled, 1,
     PyDoc_STR("(Boolean isEnabled) -> None")},
    {"GetTrackUsage", (PyCFunction)TrackObj_GetTrackUsage, 1,
     PyDoc_STR("() -> (long _rv)")},
    {"SetTrackUsage", (PyCFunction)TrackObj_SetTrackUsage, 1,
     PyDoc_STR("(long usage) -> None")},
    {"GetTrackDuration", (PyCFunction)TrackObj_GetTrackDuration, 1,
     PyDoc_STR("() -> (TimeValue _rv)")},
    {"GetTrackOffset", (PyCFunction)TrackObj_GetTrackOffset, 1,
     PyDoc_STR("() -> (TimeValue _rv)")},
    {"SetTrackOffset", (PyCFunction)TrackObj_SetTrackOffset, 1,
     PyDoc_STR("(TimeValue movieOffsetTime) -> None")},
    {"GetTrackLayer", (PyCFunction)TrackObj_GetTrackLayer, 1,
     PyDoc_STR("() -> (short _rv)")},
    {"SetTrackLayer", (PyCFunction)TrackObj_SetTrackLayer, 1,
     PyDoc_STR("(short layer) -> None")},
    {"GetTrackAlternate", (PyCFunction)TrackObj_GetTrackAlternate, 1,
     PyDoc_STR("() -> (Track _rv)")},
    {"SetTrackAlternate", (PyCFunction)TrackObj_SetTrackAlternate, 1,
     PyDoc_STR("(Track alternateT) -> None")},
    {"GetTrackVolume", (PyCFunction)TrackObj_GetTrackVolume, 1,
     PyDoc_STR("() -> (short _rv)")},
    {"SetTrackVolume", (PyCFunction)TrackObj_SetTrackVolume, 1,
     PyDoc_STR("(short volume) -> None")},
    {"GetTrackDimensions", (PyCFunction)TrackObj_GetTrackDimensions, 1,
     PyDoc_STR("() -> (Fixed width, Fixed height)")},
    {"SetTrackDimensions", (PyCFunction)TrackObj_SetTrackDimensions, 1,
     PyDoc_STR("(Fixed width, Fixed height) -> None")},
    {"GetTrackUserData", (PyCFunction)TrackObj_GetTrackUserData, 1,
     PyDoc_STR("() -> (UserData _rv)")},
    {"GetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_GetTrackSoundLocalizationSettings, 1,
     PyDoc_STR("() -> (Handle settings)")},
    {"SetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_SetTrackSoundLocalizationSettings, 1,
     PyDoc_STR("(Handle settings) -> None")},
    {"NewTrackMedia", (PyCFunction)TrackObj_NewTrackMedia, 1,
     PyDoc_STR("(OSType mediaType, TimeScale timeScale, Handle dataRef, OSType dataRefType) -> (Media _rv)")},
    {"GetTrackMedia", (PyCFunction)TrackObj_GetTrackMedia, 1,
     PyDoc_STR("() -> (Media _rv)")},
    {"InsertMediaIntoTrack", (PyCFunction)TrackObj_InsertMediaIntoTrack, 1,
     PyDoc_STR("(TimeValue trackStart, TimeValue mediaTime, TimeValue mediaDuration, Fixed mediaRate) -> None")},
    {"InsertTrackSegment", (PyCFunction)TrackObj_InsertTrackSegment, 1,
     PyDoc_STR("(Track dstTrack, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None")},
    {"InsertEmptyTrackSegment", (PyCFunction)TrackObj_InsertEmptyTrackSegment, 1,
     PyDoc_STR("(TimeValue dstIn, TimeValue dstDuration) -> None")},
    {"DeleteTrackSegment", (PyCFunction)TrackObj_DeleteTrackSegment, 1,
     PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")},
    {"ScaleTrackSegment", (PyCFunction)TrackObj_ScaleTrackSegment, 1,
     PyDoc_STR("(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None")},
    {"IsScrapMovie", (PyCFunction)TrackObj_IsScrapMovie, 1,
     PyDoc_STR("() -> (Component _rv)")},
    {"CopyTrackSettings", (PyCFunction)TrackObj_CopyTrackSettings, 1,
     PyDoc_STR("(Track dstTrack) -> None")},
    {"AddEmptyTrackToMovie", (PyCFunction)TrackObj_AddEmptyTrackToMovie, 1,
     PyDoc_STR("(Movie dstMovie, Handle dataRef, OSType dataRefType) -> (Track dstTrack)")},
    {"AddClonedTrackToMovie", (PyCFunction)TrackObj_AddClonedTrackToMovie, 1,
     PyDoc_STR("(Movie dstMovie, long flags) -> (Track dstTrack)")},
    {"AddTrackReference", (PyCFunction)TrackObj_AddTrackReference, 1,
     PyDoc_STR("(Track refTrack, OSType refType) -> (long addedIndex)")},
    {"DeleteTrackReference", (PyCFunction)TrackObj_DeleteTrackReference, 1,
     PyDoc_STR("(OSType refType, long index) -> None")},
    {"SetTrackReference", (PyCFunction)TrackObj_SetTrackReference, 1,
     PyDoc_STR("(Track refTrack, OSType refType, long index) -> None")},
    {"GetTrackReference", (PyCFunction)TrackObj_GetTrackReference, 1,
     PyDoc_STR("(OSType refType, long index) -> (Track _rv)")},
    {"GetNextTrackReferenceType", (PyCFunction)TrackObj_GetNextTrackReferenceType, 1,
     PyDoc_STR("(OSType refType) -> (OSType _rv)")},
    {"GetTrackReferenceCount", (PyCFunction)TrackObj_GetTrackReferenceCount, 1,
     PyDoc_STR("(OSType refType) -> (long _rv)")},
    {"GetTrackEditRate", (PyCFunction)TrackObj_GetTrackEditRate, 1,
     PyDoc_STR("(TimeValue atTime) -> (Fixed _rv)")},
    {"GetTrackDataSize", (PyCFunction)TrackObj_GetTrackDataSize, 1,
     PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")},
    {"GetTrackDataSize64", (PyCFunction)TrackObj_GetTrackDataSize64, 1,
     PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")},
    {"PtInTrack", (PyCFunction)TrackObj_PtInTrack, 1,
     PyDoc_STR("(Point pt) -> (Boolean _rv)")},
    {"CopyTrackUserData", (PyCFunction)TrackObj_CopyTrackUserData, 1,
     PyDoc_STR("(Track dstTrack, OSType copyRule) -> None")},
    {"GetTrackNextInterestingTime", (PyCFunction)TrackObj_GetTrackNextInterestingTime, 1,
     PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
    {"GetTrackSegmentDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackSegmentDisplayBoundsRgn, 1,
     PyDoc_STR("(TimeValue time, TimeValue duration) -> (RgnHandle _rv)")},
    {"GetTrackStatus", (PyCFunction)TrackObj_GetTrackStatus, 1,
     PyDoc_STR("() -> (ComponentResult _rv)")},
    {"SetTrackLoadSettings", (PyCFunction)TrackObj_SetTrackLoadSettings, 1,
     PyDoc_STR("(TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints) -> None")},
    {"GetTrackLoadSettings", (PyCFunction)TrackObj_GetTrackLoadSettings, 1,
     PyDoc_STR("() -> (TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints)")},
    {NULL, NULL, 0}
};

#define TrackObj_getsetlist NULL


#define TrackObj_compare NULL

#define TrackObj_repr NULL

#define TrackObj_hash NULL
#define TrackObj_tp_init 0

#define TrackObj_tp_alloc PyType_GenericAlloc

static PyObject *TrackObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
{
    PyObject *_self;
    Track itself;
    char *kw[] = {"itself", 0};

    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, TrackObj_Convert, &itself)) return NULL;
    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    ((TrackObject *)_self)->ob_itself = itself;
    return _self;
}

#define TrackObj_tp_free PyObject_Del


PyTypeObject Track_Type = {
    PyObject_HEAD_INIT(NULL)
    0, /*ob_size*/
    "_Qt.Track", /*tp_name*/
    sizeof(TrackObject), /*tp_basicsize*/
    0, /*tp_itemsize*/
    /* methods */
    (destructor) TrackObj_dealloc, /*tp_dealloc*/
    0, /*tp_print*/
    (getattrfunc)0, /*tp_getattr*/
    (setattrfunc)0, /*tp_setattr*/
    (cmpfunc) TrackObj_compare, /*tp_compare*/
    (reprfunc) TrackObj_repr, /*tp_repr*/
    (PyNumberMethods *)0, /* tp_as_number */
    (PySequenceMethods *)0, /* tp_as_sequence */
    (PyMappingMethods *)0, /* tp_as_mapping */
    (hashfunc) TrackObj_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*/
    TrackObj_methods, /* tp_methods */
    0, /*tp_members*/
    TrackObj_getsetlist, /*tp_getset*/
    0, /*tp_base*/
    0, /*tp_dict*/
    0, /*tp_descr_get*/
    0, /*tp_descr_set*/
    0, /*tp_dictoffset*/
    TrackObj_tp_init, /* tp_init */
    TrackObj_tp_alloc, /* tp_alloc */
    TrackObj_tp_new, /* tp_new */
    TrackObj_tp_free, /* tp_free */
};

/* --------------------- End object type Track ---------------------- */


/* ----------------------- Object type Movie ------------------------ */

PyTypeObject Movie_Type;

#define MovieObj_Check(x) ((x)->ob_type == &Movie_Type || PyObject_TypeCheck((x), &Movie_Type))

typedef struct MovieObject {
    PyObject_HEAD
    Movie ob_itself;
} MovieObject;

PyObject *MovieObj_New(Movie itself)
{
    MovieObject *it;
    if (itself == NULL) {
                                    PyErr_SetString(Qt_Error,"Cannot create Movie from NULL pointer");
                                    return NULL;
                            }
    it = PyObject_NEW(MovieObject, &Movie_Type);
    if (it == NULL) return NULL;
    it->ob_itself = itself;
    return (PyObject *)it;
}

int MovieObj_Convert(PyObject *v, Movie *p_itself)
{
    if (v == Py_None)
    {
        *p_itself = NULL;
        return 1;
    }
    if (!MovieObj_Check(v))
    {
        PyErr_SetString(PyExc_TypeError, "Movie required");
        return 0;
    }
    *p_itself = ((MovieObject *)v)->ob_itself;
    return 1;
}

static void MovieObj_dealloc(MovieObject *self)
{
    if (self->ob_itself) DisposeMovie(self->ob_itself);
    self->ob_type->tp_free((PyObject *)self);
}

static PyObject *MovieObj_MoviesTask(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long maxMilliSecToUse;
#ifndef MoviesTask
    PyMac_PRECHECK(MoviesTask);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &maxMilliSecToUse))
        return NULL;
    MoviesTask(_self->ob_itself,
               maxMilliSecToUse);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_PrerollMovie(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue time;
    Fixed Rate;
#ifndef PrerollMovie
    PyMac_PRECHECK(PrerollMovie);
#endif
    if (!PyArg_ParseTuple(_args, "lO&",
                          &time,
                          PyMac_GetFixed, &Rate))
        return NULL;
    _err = PrerollMovie(_self->ob_itself,
                        time,
                        Rate);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_AbortPrePrerollMovie(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr err;
#ifndef AbortPrePrerollMovie
    PyMac_PRECHECK(AbortPrePrerollMovie);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &err))
        return NULL;
    AbortPrePrerollMovie(_self->ob_itself,
                         err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_LoadMovieIntoRam(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue time;
    TimeValue duration;
    long flags;
#ifndef LoadMovieIntoRam
    PyMac_PRECHECK(LoadMovieIntoRam);
#endif
    if (!PyArg_ParseTuple(_args, "lll",
                          &time,
                          &duration,
                          &flags))
        return NULL;
    _err = LoadMovieIntoRam(_self->ob_itself,
                            time,
                            duration,
                            flags);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_SetMovieActive(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean active;
#ifndef SetMovieActive
    PyMac_PRECHECK(SetMovieActive);
#endif
    if (!PyArg_ParseTuple(_args, "b",
                          &active))
        return NULL;
    SetMovieActive(_self->ob_itself,
                   active);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

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

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

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

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

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

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

static PyObject *MovieObj_SetMoviePreviewMode(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean usePreview;
#ifndef SetMoviePreviewMode
    PyMac_PRECHECK(SetMoviePreviewMode);
#endif
    if (!PyArg_ParseTuple(_args, "b",
                          &usePreview))
        return NULL;
    SetMoviePreviewMode(_self->ob_itself,
                        usePreview);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

static PyObject *MovieObj_GetMovieTimeBase(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeBase _rv;
#ifndef GetMovieTimeBase
    PyMac_PRECHECK(GetMovieTimeBase);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieTimeBase(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         TimeBaseObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_SetMovieMasterTimeBase(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeBase tb;
    TimeRecord slaveZero;
#ifndef SetMovieMasterTimeBase
    PyMac_PRECHECK(SetMovieMasterTimeBase);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          TimeBaseObj_Convert, &tb,
                          QtTimeRecord_Convert, &slaveZero))
        return NULL;
    SetMovieMasterTimeBase(_self->ob_itself,
                           tb,
                           &slaveZero);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_SetMovieMasterClock(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Component clockMeister;
    TimeRecord slaveZero;
#ifndef SetMovieMasterClock
    PyMac_PRECHECK(SetMovieMasterClock);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpObj_Convert, &clockMeister,
                          QtTimeRecord_Convert, &slaveZero))
        return NULL;
    SetMovieMasterClock(_self->ob_itself,
                        clockMeister,
                        &slaveZero);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_ChooseMovieClock(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long flags;
#ifndef ChooseMovieClock
    PyMac_PRECHECK(ChooseMovieClock);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &flags))
        return NULL;
    ChooseMovieClock(_self->ob_itself,
                     flags);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieGWorld(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    CGrafPtr port;
    GDHandle gdh;
#ifndef GetMovieGWorld
    PyMac_PRECHECK(GetMovieGWorld);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetMovieGWorld(_self->ob_itself,
                   &port,
                   &gdh);
    _res = Py_BuildValue("O&O&",
                         GrafObj_New, port,
                         OptResObj_New, gdh);
    return _res;
}

static PyObject *MovieObj_SetMovieGWorld(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    CGrafPtr port;
    GDHandle gdh;
#ifndef SetMovieGWorld
    PyMac_PRECHECK(SetMovieGWorld);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          GrafObj_Convert, &port,
                          OptResObj_Convert, &gdh))
        return NULL;
    SetMovieGWorld(_self->ob_itself,
                   port,
                   gdh);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieNaturalBoundsRect(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Rect naturalBounds;
#ifndef GetMovieNaturalBoundsRect
    PyMac_PRECHECK(GetMovieNaturalBoundsRect);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetMovieNaturalBoundsRect(_self->ob_itself,
                              &naturalBounds);
    _res = Py_BuildValue("O&",
                         PyMac_BuildRect, &naturalBounds);
    return _res;
}

static PyObject *MovieObj_GetNextTrackForCompositing(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Track _rv;
    Track theTrack;
#ifndef GetNextTrackForCompositing
    PyMac_PRECHECK(GetNextTrackForCompositing);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          TrackObj_Convert, &theTrack))
        return NULL;
    _rv = GetNextTrackForCompositing(_self->ob_itself,
                                     theTrack);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetPrevTrackForCompositing(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Track _rv;
    Track theTrack;
#ifndef GetPrevTrackForCompositing
    PyMac_PRECHECK(GetPrevTrackForCompositing);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          TrackObj_Convert, &theTrack))
        return NULL;
    _rv = GetPrevTrackForCompositing(_self->ob_itself,
                                     theTrack);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetMoviePict(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    PicHandle _rv;
    TimeValue time;
#ifndef GetMoviePict
    PyMac_PRECHECK(GetMoviePict);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &time))
        return NULL;
    _rv = GetMoviePict(_self->ob_itself,
                       time);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

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

static PyObject *MovieObj_UpdateMovie(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
#ifndef UpdateMovie
    PyMac_PRECHECK(UpdateMovie);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = UpdateMovie(_self->ob_itself);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_InvalidateMovieRegion(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    RgnHandle invalidRgn;
#ifndef InvalidateMovieRegion
    PyMac_PRECHECK(InvalidateMovieRegion);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &invalidRgn))
        return NULL;
    _err = InvalidateMovieRegion(_self->ob_itself,
                                 invalidRgn);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieBox(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Rect boxRect;
#ifndef GetMovieBox
    PyMac_PRECHECK(GetMovieBox);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetMovieBox(_self->ob_itself,
                &boxRect);
    _res = Py_BuildValue("O&",
                         PyMac_BuildRect, &boxRect);
    return _res;
}

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

static PyObject *MovieObj_GetMovieDisplayClipRgn(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    RgnHandle _rv;
#ifndef GetMovieDisplayClipRgn
    PyMac_PRECHECK(GetMovieDisplayClipRgn);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieDisplayClipRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

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

static PyObject *MovieObj_GetMovieClipRgn(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    RgnHandle _rv;
#ifndef GetMovieClipRgn
    PyMac_PRECHECK(GetMovieClipRgn);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieClipRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

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

static PyObject *MovieObj_GetMovieDisplayBoundsRgn(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    RgnHandle _rv;
#ifndef GetMovieDisplayBoundsRgn
    PyMac_PRECHECK(GetMovieDisplayBoundsRgn);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieDisplayBoundsRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetMovieBoundsRgn(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    RgnHandle _rv;
#ifndef GetMovieBoundsRgn
    PyMac_PRECHECK(GetMovieBoundsRgn);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieBoundsRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_SetMovieVideoOutput(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentInstance vout;
#ifndef SetMovieVideoOutput
    PyMac_PRECHECK(SetMovieVideoOutput);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &vout))
        return NULL;
    SetMovieVideoOutput(_self->ob_itself,
                        vout);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_PutMovieIntoHandle(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle publicMovie;
#ifndef PutMovieIntoHandle
    PyMac_PRECHECK(PutMovieIntoHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &publicMovie))
        return NULL;
    _err = PutMovieIntoHandle(_self->ob_itself,
                              publicMovie);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_PutMovieIntoDataFork(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    short fRefNum;
    long offset;
    long maxSize;
#ifndef PutMovieIntoDataFork
    PyMac_PRECHECK(PutMovieIntoDataFork);
#endif
    if (!PyArg_ParseTuple(_args, "hll",
                          &fRefNum,
                          &offset,
                          &maxSize))
        return NULL;
    _err = PutMovieIntoDataFork(_self->ob_itself,
                                fRefNum,
                                offset,
                                maxSize);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_PutMovieIntoDataFork64(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    long fRefNum;
    wide offset;
    unsigned long maxSize;
#ifndef PutMovieIntoDataFork64
    PyMac_PRECHECK(PutMovieIntoDataFork64);
#endif
    if (!PyArg_ParseTuple(_args, "lO&l",
                          &fRefNum,
                          PyMac_Getwide, &offset,
                          &maxSize))
        return NULL;
    _err = PutMovieIntoDataFork64(_self->ob_itself,
                                  fRefNum,
                                  &offset,
                                  maxSize);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_PutMovieIntoStorage(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    DataHandler dh;
    wide offset;
    unsigned long maxSize;
#ifndef PutMovieIntoStorage
    PyMac_PRECHECK(PutMovieIntoStorage);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          CmpInstObj_Convert, &dh,
                          PyMac_Getwide, &offset,
                          &maxSize))
        return NULL;
    _err = PutMovieIntoStorage(_self->ob_itself,
                               dh,
                               &offset,
                               maxSize);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_PutMovieForDataRefIntoHandle(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataRef;
    OSType dataRefType;
    Handle publicMovie;
#ifndef PutMovieForDataRefIntoHandle
    PyMac_PRECHECK(PutMovieForDataRefIntoHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType,
                          ResObj_Convert, &publicMovie))
        return NULL;
    _err = PutMovieForDataRefIntoHandle(_self->ob_itself,
                                        dataRef,
                                        dataRefType,
                                        publicMovie);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

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

static PyObject *MovieObj_GetMovieTimeScale(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeScale _rv;
#ifndef GetMovieTimeScale
    PyMac_PRECHECK(GetMovieTimeScale);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieTimeScale(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieObj_SetMovieTimeScale(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeScale timeScale;
#ifndef SetMovieTimeScale
    PyMac_PRECHECK(SetMovieTimeScale);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &timeScale))
        return NULL;
    SetMovieTimeScale(_self->ob_itself,
                      timeScale);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieDuration(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue _rv;
#ifndef GetMovieDuration
    PyMac_PRECHECK(GetMovieDuration);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieDuration(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieObj_GetMovieRate(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed _rv;
#ifndef GetMovieRate
    PyMac_PRECHECK(GetMovieRate);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieRate(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *MovieObj_SetMovieRate(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed rate;
#ifndef SetMovieRate
    PyMac_PRECHECK(SetMovieRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetFixed, &rate))
        return NULL;
    SetMovieRate(_self->ob_itself,
                 rate);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMoviePreferredRate(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed _rv;
#ifndef GetMoviePreferredRate
    PyMac_PRECHECK(GetMoviePreferredRate);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMoviePreferredRate(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *MovieObj_SetMoviePreferredRate(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed rate;
#ifndef SetMoviePreferredRate
    PyMac_PRECHECK(SetMoviePreferredRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetFixed, &rate))
        return NULL;
    SetMoviePreferredRate(_self->ob_itself,
                          rate);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

static PyObject *MovieObj_SetMoviePreferredVolume(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short volume;
#ifndef SetMoviePreferredVolume
    PyMac_PRECHECK(SetMoviePreferredVolume);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &volume))
        return NULL;
    SetMoviePreferredVolume(_self->ob_itself,
                            volume);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

static PyObject *MovieObj_SetMovieVolume(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short volume;
#ifndef SetMovieVolume
    PyMac_PRECHECK(SetMovieVolume);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &volume))
        return NULL;
    SetMovieVolume(_self->ob_itself,
                   volume);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMoviePreviewTime(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue previewTime;
    TimeValue previewDuration;
#ifndef GetMoviePreviewTime
    PyMac_PRECHECK(GetMoviePreviewTime);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetMoviePreviewTime(_self->ob_itself,
                        &previewTime,
                        &previewDuration);
    _res = Py_BuildValue("ll",
                         previewTime,
                         previewDuration);
    return _res;
}

static PyObject *MovieObj_SetMoviePreviewTime(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue previewTime;
    TimeValue previewDuration;
#ifndef SetMoviePreviewTime
    PyMac_PRECHECK(SetMoviePreviewTime);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &previewTime,
                          &previewDuration))
        return NULL;
    SetMoviePreviewTime(_self->ob_itself,
                        previewTime,
                        previewDuration);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMoviePosterTime(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue _rv;
#ifndef GetMoviePosterTime
    PyMac_PRECHECK(GetMoviePosterTime);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMoviePosterTime(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieObj_SetMoviePosterTime(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue posterTime;
#ifndef SetMoviePosterTime
    PyMac_PRECHECK(SetMoviePosterTime);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &posterTime))
        return NULL;
    SetMoviePosterTime(_self->ob_itself,
                       posterTime);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieSelection(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue selectionTime;
    TimeValue selectionDuration;
#ifndef GetMovieSelection
    PyMac_PRECHECK(GetMovieSelection);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetMovieSelection(_self->ob_itself,
                      &selectionTime,
                      &selectionDuration);
    _res = Py_BuildValue("ll",
                         selectionTime,
                         selectionDuration);
    return _res;
}

static PyObject *MovieObj_SetMovieSelection(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue selectionTime;
    TimeValue selectionDuration;
#ifndef SetMovieSelection
    PyMac_PRECHECK(SetMovieSelection);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &selectionTime,
                          &selectionDuration))
        return NULL;
    SetMovieSelection(_self->ob_itself,
                      selectionTime,
                      selectionDuration);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_SetMovieActiveSegment(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue startTime;
    TimeValue duration;
#ifndef SetMovieActiveSegment
    PyMac_PRECHECK(SetMovieActiveSegment);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    SetMovieActiveSegment(_self->ob_itself,
                          startTime,
                          duration);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieActiveSegment(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue startTime;
    TimeValue duration;
#ifndef GetMovieActiveSegment
    PyMac_PRECHECK(GetMovieActiveSegment);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetMovieActiveSegment(_self->ob_itself,
                          &startTime,
                          &duration);
    _res = Py_BuildValue("ll",
                         startTime,
                         duration);
    return _res;
}

static PyObject *MovieObj_GetMovieTime(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue _rv;
    TimeRecord currentTime;
#ifndef GetMovieTime
    PyMac_PRECHECK(GetMovieTime);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieTime(_self->ob_itself,
                       &currentTime);
    _res = Py_BuildValue("lO&",
                         _rv,
                         QtTimeRecord_New, &currentTime);
    return _res;
}

static PyObject *MovieObj_SetMovieTime(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeRecord newtime;
#ifndef SetMovieTime
    PyMac_PRECHECK(SetMovieTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          QtTimeRecord_Convert, &newtime))
        return NULL;
    SetMovieTime(_self->ob_itself,
                 &newtime);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_SetMovieTimeValue(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue newtime;
#ifndef SetMovieTimeValue
    PyMac_PRECHECK(SetMovieTimeValue);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &newtime))
        return NULL;
    SetMovieTimeValue(_self->ob_itself,
                      newtime);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieUserData(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    UserData _rv;
#ifndef GetMovieUserData
    PyMac_PRECHECK(GetMovieUserData);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieUserData(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         UserDataObj_New, _rv);
    return _res;
}

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

static PyObject *MovieObj_GetMovieTrack(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Track _rv;
    long trackID;
#ifndef GetMovieTrack
    PyMac_PRECHECK(GetMovieTrack);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &trackID))
        return NULL;
    _rv = GetMovieTrack(_self->ob_itself,
                        trackID);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetMovieIndTrack(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Track _rv;
    long index;
#ifndef GetMovieIndTrack
    PyMac_PRECHECK(GetMovieIndTrack);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &index))
        return NULL;
    _rv = GetMovieIndTrack(_self->ob_itself,
                           index);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetMovieIndTrackType(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Track _rv;
    long index;
    OSType trackType;
    long flags;
#ifndef GetMovieIndTrackType
    PyMac_PRECHECK(GetMovieIndTrackType);
#endif
    if (!PyArg_ParseTuple(_args, "lO&l",
                          &index,
                          PyMac_GetOSType, &trackType,
                          &flags))
        return NULL;
    _rv = GetMovieIndTrackType(_self->ob_itself,
                               index,
                               trackType,
                               flags);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_NewMovieTrack(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Track _rv;
    Fixed width;
    Fixed height;
    short trackVolume;
#ifndef NewMovieTrack
    PyMac_PRECHECK(NewMovieTrack);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&h",
                          PyMac_GetFixed, &width,
                          PyMac_GetFixed, &height,
                          &trackVolume))
        return NULL;
    _rv = NewMovieTrack(_self->ob_itself,
                        width,
                        height,
                        trackVolume);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_SetAutoTrackAlternatesEnabled(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean enable;
#ifndef SetAutoTrackAlternatesEnabled
    PyMac_PRECHECK(SetAutoTrackAlternatesEnabled);
#endif
    if (!PyArg_ParseTuple(_args, "b",
                          &enable))
        return NULL;
    SetAutoTrackAlternatesEnabled(_self->ob_itself,
                                  enable);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

static PyObject *MovieObj_InsertMovieSegment(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie dstMovie;
    TimeValue srcIn;
    TimeValue srcDuration;
    TimeValue dstIn;
#ifndef InsertMovieSegment
    PyMac_PRECHECK(InsertMovieSegment);
#endif
    if (!PyArg_ParseTuple(_args, "O&lll",
                          MovieObj_Convert, &dstMovie,
                          &srcIn,
                          &srcDuration,
                          &dstIn))
        return NULL;
    _err = InsertMovieSegment(_self->ob_itself,
                              dstMovie,
                              srcIn,
                              srcDuration,
                              dstIn);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_InsertEmptyMovieSegment(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue dstIn;
    TimeValue dstDuration;
#ifndef InsertEmptyMovieSegment
    PyMac_PRECHECK(InsertEmptyMovieSegment);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &dstIn,
                          &dstDuration))
        return NULL;
    _err = InsertEmptyMovieSegment(_self->ob_itself,
                                   dstIn,
                                   dstDuration);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_DeleteMovieSegment(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue startTime;
    TimeValue duration;
#ifndef DeleteMovieSegment
    PyMac_PRECHECK(DeleteMovieSegment);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    _err = DeleteMovieSegment(_self->ob_itself,
                              startTime,
                              duration);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_ScaleMovieSegment(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue startTime;
    TimeValue oldDuration;
    TimeValue newDuration;
#ifndef ScaleMovieSegment
    PyMac_PRECHECK(ScaleMovieSegment);
#endif
    if (!PyArg_ParseTuple(_args, "lll",
                          &startTime,
                          &oldDuration,
                          &newDuration))
        return NULL;
    _err = ScaleMovieSegment(_self->ob_itself,
                             startTime,
                             oldDuration,
                             newDuration);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_CutMovieSelection(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Movie _rv;
#ifndef CutMovieSelection
    PyMac_PRECHECK(CutMovieSelection);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = CutMovieSelection(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_CopyMovieSelection(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Movie _rv;
#ifndef CopyMovieSelection
    PyMac_PRECHECK(CopyMovieSelection);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = CopyMovieSelection(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_PasteMovieSelection(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Movie src;
#ifndef PasteMovieSelection
    PyMac_PRECHECK(PasteMovieSelection);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          MovieObj_Convert, &src))
        return NULL;
    PasteMovieSelection(_self->ob_itself,
                        src);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_AddMovieSelection(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Movie src;
#ifndef AddMovieSelection
    PyMac_PRECHECK(AddMovieSelection);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          MovieObj_Convert, &src))
        return NULL;
    AddMovieSelection(_self->ob_itself,
                      src);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

static PyObject *MovieObj_PutMovieIntoTypedHandle(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Track targetTrack;
    OSType handleType;
    Handle publicMovie;
    TimeValue start;
    TimeValue dur;
    long flags;
    ComponentInstance userComp;
#ifndef PutMovieIntoTypedHandle
    PyMac_PRECHECK(PutMovieIntoTypedHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&lllO&",
                          TrackObj_Convert, &targetTrack,
                          PyMac_GetOSType, &handleType,
                          ResObj_Convert, &publicMovie,
                          &start,
                          &dur,
                          &flags,
                          CmpInstObj_Convert, &userComp))
        return NULL;
    _err = PutMovieIntoTypedHandle(_self->ob_itself,
                                   targetTrack,
                                   handleType,
                                   publicMovie,
                                   start,
                                   dur,
                                   flags,
                                   userComp);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_CopyMovieSettings(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie dstMovie;
#ifndef CopyMovieSettings
    PyMac_PRECHECK(CopyMovieSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          MovieObj_Convert, &dstMovie))
        return NULL;
    _err = CopyMovieSettings(_self->ob_itself,
                             dstMovie);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_ConvertMovieToFile(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Track onlyTrack;
    FSSpec outputFile;
    OSType fileType;
    OSType creator;
    ScriptCode scriptTag;
    short resID;
    long flags;
    ComponentInstance userComp;
#ifndef ConvertMovieToFile
    PyMac_PRECHECK(ConvertMovieToFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&hlO&",
                          TrackObj_Convert, &onlyTrack,
                          PyMac_GetFSSpec, &outputFile,
                          PyMac_GetOSType, &fileType,
                          PyMac_GetOSType, &creator,
                          &scriptTag,
                          &flags,
                          CmpInstObj_Convert, &userComp))
        return NULL;
    _err = ConvertMovieToFile(_self->ob_itself,
                              onlyTrack,
                              &outputFile,
                              fileType,
                              creator,
                              scriptTag,
                              &resID,
                              flags,
                              userComp);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         resID);
    return _res;
}

static PyObject *MovieObj_GetMovieDataSize(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
    TimeValue startTime;
    TimeValue duration;
#ifndef GetMovieDataSize
    PyMac_PRECHECK(GetMovieDataSize);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    _rv = GetMovieDataSize(_self->ob_itself,
                           startTime,
                           duration);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieObj_GetMovieDataSize64(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue startTime;
    TimeValue duration;
    wide dataSize;
#ifndef GetMovieDataSize64
    PyMac_PRECHECK(GetMovieDataSize64);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    _err = GetMovieDataSize64(_self->ob_itself,
                              startTime,
                              duration,
                              &dataSize);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         PyMac_Buildwide, dataSize);
    return _res;
}

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

static PyObject *MovieObj_SetMovieLanguage(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long language;
#ifndef SetMovieLanguage
    PyMac_PRECHECK(SetMovieLanguage);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &language))
        return NULL;
    SetMovieLanguage(_self->ob_itself,
                     language);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_CopyMovieUserData(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie dstMovie;
    OSType copyRule;
#ifndef CopyMovieUserData
    PyMac_PRECHECK(CopyMovieUserData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          MovieObj_Convert, &dstMovie,
                          PyMac_GetOSType, &copyRule))
        return NULL;
    _err = CopyMovieUserData(_self->ob_itself,
                             dstMovie,
                             copyRule);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieNextInterestingTime(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short interestingTimeFlags;
    short numMediaTypes;
    OSType whichMediaTypes;
    TimeValue time;
    Fixed rate;
    TimeValue interestingTime;
    TimeValue interestingDuration;
#ifndef GetMovieNextInterestingTime
    PyMac_PRECHECK(GetMovieNextInterestingTime);
#endif
    if (!PyArg_ParseTuple(_args, "hhO&lO&",
                          &interestingTimeFlags,
                          &numMediaTypes,
                          PyMac_GetOSType, &whichMediaTypes,
                          &time,
                          PyMac_GetFixed, &rate))
        return NULL;
    GetMovieNextInterestingTime(_self->ob_itself,
                                interestingTimeFlags,
                                numMediaTypes,
                                &whichMediaTypes,
                                time,
                                rate,
                                &interestingTime,
                                &interestingDuration);
    _res = Py_BuildValue("ll",
                         interestingTime,
                         interestingDuration);
    return _res;
}

static PyObject *MovieObj_AddMovieResource(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    short resRefNum;
    short resId;
    Str255 resName;
#ifndef AddMovieResource
    PyMac_PRECHECK(AddMovieResource);
#endif
    if (!PyArg_ParseTuple(_args, "hO&",
                          &resRefNum,
                          PyMac_GetStr255, resName))
        return NULL;
    _err = AddMovieResource(_self->ob_itself,
                            resRefNum,
                            &resId,
                            resName);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         resId);
    return _res;
}

static PyObject *MovieObj_UpdateMovieResource(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    short resRefNum;
    short resId;
    Str255 resName;
#ifndef UpdateMovieResource
    PyMac_PRECHECK(UpdateMovieResource);
#endif
    if (!PyArg_ParseTuple(_args, "hhO&",
                          &resRefNum,
                          &resId,
                          PyMac_GetStr255, resName))
        return NULL;
    _err = UpdateMovieResource(_self->ob_itself,
                               resRefNum,
                               resId,
                               resName);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_AddMovieToStorage(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    DataHandler dh;
#ifndef AddMovieToStorage
    PyMac_PRECHECK(AddMovieToStorage);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _err = AddMovieToStorage(_self->ob_itself,
                             dh);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_UpdateMovieInStorage(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    DataHandler dh;
#ifndef UpdateMovieInStorage
    PyMac_PRECHECK(UpdateMovieInStorage);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _err = UpdateMovieInStorage(_self->ob_itself,
                                dh);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

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

static PyObject *MovieObj_SetMovieDefaultDataRef(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataRef;
    OSType dataRefType;
#ifndef SetMovieDefaultDataRef
    PyMac_PRECHECK(SetMovieDefaultDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _err = SetMovieDefaultDataRef(_self->ob_itself,
                                  dataRef,
                                  dataRefType);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieDefaultDataRef(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataRef;
    OSType dataRefType;
#ifndef GetMovieDefaultDataRef
    PyMac_PRECHECK(GetMovieDefaultDataRef);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetMovieDefaultDataRef(_self->ob_itself,
                                  &dataRef,
                                  &dataRefType);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&O&",
                         ResObj_New, dataRef,
                         PyMac_BuildOSType, dataRefType);
    return _res;
}

static PyObject *MovieObj_SetMovieColorTable(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    CTabHandle ctab;
#ifndef SetMovieColorTable
    PyMac_PRECHECK(SetMovieColorTable);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &ctab))
        return NULL;
    _err = SetMovieColorTable(_self->ob_itself,
                              ctab);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieColorTable(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    CTabHandle ctab;
#ifndef GetMovieColorTable
    PyMac_PRECHECK(GetMovieColorTable);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetMovieColorTable(_self->ob_itself,
                              &ctab);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         ResObj_New, ctab);
    return _res;
}

static PyObject *MovieObj_FlattenMovie(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long movieFlattenFlags;
    FSSpec theFile;
    OSType creator;
    ScriptCode scriptTag;
    long createMovieFileFlags;
    short resId;
    Str255 resName;
#ifndef FlattenMovie
    PyMac_PRECHECK(FlattenMovie);
#endif
    if (!PyArg_ParseTuple(_args, "lO&O&hlO&",
                          &movieFlattenFlags,
                          PyMac_GetFSSpec, &theFile,
                          PyMac_GetOSType, &creator,
                          &scriptTag,
                          &createMovieFileFlags,
                          PyMac_GetStr255, resName))
        return NULL;
    FlattenMovie(_self->ob_itself,
                 movieFlattenFlags,
                 &theFile,
                 creator,
                 scriptTag,
                 createMovieFileFlags,
                 &resId,
                 resName);
    _res = Py_BuildValue("h",
                         resId);
    return _res;
}

static PyObject *MovieObj_FlattenMovieData(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Movie _rv;
    long movieFlattenFlags;
    FSSpec theFile;
    OSType creator;
    ScriptCode scriptTag;
    long createMovieFileFlags;
#ifndef FlattenMovieData
    PyMac_PRECHECK(FlattenMovieData);
#endif
    if (!PyArg_ParseTuple(_args, "lO&O&hl",
                          &movieFlattenFlags,
                          PyMac_GetFSSpec, &theFile,
                          PyMac_GetOSType, &creator,
                          &scriptTag,
                          &createMovieFileFlags))
        return NULL;
    _rv = FlattenMovieData(_self->ob_itself,
                           movieFlattenFlags,
                           &theFile,
                           creator,
                           scriptTag,
                           createMovieFileFlags);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_FlattenMovieDataToDataRef(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Movie _rv;
    long movieFlattenFlags;
    Handle dataRef;
    OSType dataRefType;
    OSType creator;
    ScriptCode scriptTag;
    long createMovieFileFlags;
#ifndef FlattenMovieDataToDataRef
    PyMac_PRECHECK(FlattenMovieDataToDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "lO&O&O&hl",
                          &movieFlattenFlags,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType,
                          PyMac_GetOSType, &creator,
                          &scriptTag,
                          &createMovieFileFlags))
        return NULL;
    _rv = FlattenMovieDataToDataRef(_self->ob_itself,
                                    movieFlattenFlags,
                                    dataRef,
                                    dataRefType,
                                    creator,
                                    scriptTag,
                                    createMovieFileFlags);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_MovieSearchText(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Ptr text;
    long size;
    long searchFlags;
    Track searchTrack;
    TimeValue searchTime;
    long searchOffset;
#ifndef MovieSearchText
    PyMac_PRECHECK(MovieSearchText);
#endif
    if (!PyArg_ParseTuple(_args, "sll",
                          &text,
                          &size,
                          &searchFlags))
        return NULL;
    _err = MovieSearchText(_self->ob_itself,
                           text,
                           size,
                           searchFlags,
                           &searchTrack,
                           &searchTime,
                           &searchOffset);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&ll",
                         TrackObj_New, searchTrack,
                         searchTime,
                         searchOffset);
    return _res;
}

static PyObject *MovieObj_GetPosterBox(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Rect boxRect;
#ifndef GetPosterBox
    PyMac_PRECHECK(GetPosterBox);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetPosterBox(_self->ob_itself,
                 &boxRect);
    _res = Py_BuildValue("O&",
                         PyMac_BuildRect, &boxRect);
    return _res;
}

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

static PyObject *MovieObj_GetMovieSegmentDisplayBoundsRgn(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    TimeValue time;
    TimeValue duration;
#ifndef GetMovieSegmentDisplayBoundsRgn
    PyMac_PRECHECK(GetMovieSegmentDisplayBoundsRgn);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &time,
                          &duration))
        return NULL;
    _rv = GetMovieSegmentDisplayBoundsRgn(_self->ob_itself,
                                          time,
                                          duration);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetMovieStatus(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Track firstProblemTrack;
#ifndef GetMovieStatus
    PyMac_PRECHECK(GetMovieStatus);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieStatus(_self->ob_itself,
                         &firstProblemTrack);
    _res = Py_BuildValue("lO&",
                         _rv,
                         TrackObj_New, firstProblemTrack);
    return _res;
}

static PyObject *MovieObj_NewMovieController(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MovieController _rv;
    Rect movieRect;
    long someFlags;
#ifndef NewMovieController
    PyMac_PRECHECK(NewMovieController);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          PyMac_GetRect, &movieRect,
                          &someFlags))
        return NULL;
    _rv = NewMovieController(_self->ob_itself,
                             &movieRect,
                             someFlags);
    _res = Py_BuildValue("O&",
                         MovieCtlObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_PutMovieOnScrap(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    long movieScrapFlags;
#ifndef PutMovieOnScrap
    PyMac_PRECHECK(PutMovieOnScrap);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &movieScrapFlags))
        return NULL;
    _err = PutMovieOnScrap(_self->ob_itself,
                           movieScrapFlags);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_SetMoviePlayHints(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long flags;
    long flagsMask;
#ifndef SetMoviePlayHints
    PyMac_PRECHECK(SetMoviePlayHints);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &flags,
                          &flagsMask))
        return NULL;
    SetMoviePlayHints(_self->ob_itself,
                      flags,
                      flagsMask);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMaxLoadedTimeInMovie(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue time;
#ifndef GetMaxLoadedTimeInMovie
    PyMac_PRECHECK(GetMaxLoadedTimeInMovie);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetMaxLoadedTimeInMovie(_self->ob_itself,
                                   &time);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         time);
    return _res;
}

static PyObject *MovieObj_QTMovieNeedsTimeTable(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Boolean needsTimeTable;
#ifndef QTMovieNeedsTimeTable
    PyMac_PRECHECK(QTMovieNeedsTimeTable);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = QTMovieNeedsTimeTable(_self->ob_itself,
                                 &needsTimeTable);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("b",
                         needsTimeTable);
    return _res;
}

static PyObject *MovieObj_QTGetDataRefMaxFileOffset(MovieObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    OSType dataRefType;
    Handle dataRef;
    long offset;
#ifndef QTGetDataRefMaxFileOffset
    PyMac_PRECHECK(QTGetDataRefMaxFileOffset);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          PyMac_GetOSType, &dataRefType,
                          ResObj_Convert, &dataRef))
        return NULL;
    _err = QTGetDataRefMaxFileOffset(_self->ob_itself,
                                     dataRefType,
                                     dataRef,
                                     &offset);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         offset);
    return _res;
}

static PyMethodDef MovieObj_methods[] = {
    {"MoviesTask", (PyCFunction)MovieObj_MoviesTask, 1,
     PyDoc_STR("(long maxMilliSecToUse) -> None")},
    {"PrerollMovie", (PyCFunction)MovieObj_PrerollMovie, 1,
     PyDoc_STR("(TimeValue time, Fixed Rate) -> None")},
    {"AbortPrePrerollMovie", (PyCFunction)MovieObj_AbortPrePrerollMovie, 1,
     PyDoc_STR("(OSErr err) -> None")},
    {"LoadMovieIntoRam", (PyCFunction)MovieObj_LoadMovieIntoRam, 1,
     PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")},
    {"SetMovieActive", (PyCFunction)MovieObj_SetMovieActive, 1,
     PyDoc_STR("(Boolean active) -> None")},
    {"GetMovieActive", (PyCFunction)MovieObj_GetMovieActive, 1,
     PyDoc_STR("() -> (Boolean _rv)")},
    {"StartMovie", (PyCFunction)MovieObj_StartMovie, 1,
     PyDoc_STR("() -> None")},
    {"StopMovie", (PyCFunction)MovieObj_StopMovie, 1,
     PyDoc_STR("() -> None")},
    {"GoToBeginningOfMovie", (PyCFunction)MovieObj_GoToBeginningOfMovie, 1,
     PyDoc_STR("() -> None")},
    {"GoToEndOfMovie", (PyCFunction)MovieObj_GoToEndOfMovie, 1,
     PyDoc_STR("() -> None")},
    {"IsMovieDone", (PyCFunction)MovieObj_IsMovieDone, 1,
     PyDoc_STR("() -> (Boolean _rv)")},
    {"GetMoviePreviewMode", (PyCFunction)MovieObj_GetMoviePreviewMode, 1,
     PyDoc_STR("() -> (Boolean _rv)")},
    {"SetMoviePreviewMode", (PyCFunction)MovieObj_SetMoviePreviewMode, 1,
     PyDoc_STR("(Boolean usePreview) -> None")},
    {"ShowMoviePoster", (PyCFunction)MovieObj_ShowMoviePoster, 1,
     PyDoc_STR("() -> None")},
    {"GetMovieTimeBase", (PyCFunction)MovieObj_GetMovieTimeBase, 1,
     PyDoc_STR("() -> (TimeBase _rv)")},
    {"SetMovieMasterTimeBase", (PyCFunction)MovieObj_SetMovieMasterTimeBase, 1,
     PyDoc_STR("(TimeBase tb, TimeRecord slaveZero) -> None")},
    {"SetMovieMasterClock", (PyCFunction)MovieObj_SetMovieMasterClock, 1,
     PyDoc_STR("(Component clockMeister, TimeRecord slaveZero) -> None")},
    {"ChooseMovieClock", (PyCFunction)MovieObj_ChooseMovieClock, 1,
     PyDoc_STR("(long flags) -> None")},
    {"GetMovieGWorld", (PyCFunction)MovieObj_GetMovieGWorld, 1,
     PyDoc_STR("() -> (CGrafPtr port, GDHandle gdh)")},
    {"SetMovieGWorld", (PyCFunction)MovieObj_SetMovieGWorld, 1,
     PyDoc_STR("(CGrafPtr port, GDHandle gdh) -> None")},
    {"GetMovieNaturalBoundsRect", (PyCFunction)MovieObj_GetMovieNaturalBoundsRect, 1,
     PyDoc_STR("() -> (Rect naturalBounds)")},
    {"GetNextTrackForCompositing", (PyCFunction)MovieObj_GetNextTrackForCompositing, 1,
     PyDoc_STR("(Track theTrack) -> (Track _rv)")},
    {"GetPrevTrackForCompositing", (PyCFunction)MovieObj_GetPrevTrackForCompositing, 1,
     PyDoc_STR("(Track theTrack) -> (Track _rv)")},
    {"GetMoviePict", (PyCFunction)MovieObj_GetMoviePict, 1,
     PyDoc_STR("(TimeValue time) -> (PicHandle _rv)")},
    {"GetMoviePosterPict", (PyCFunction)MovieObj_GetMoviePosterPict, 1,
     PyDoc_STR("() -> (PicHandle _rv)")},
    {"UpdateMovie", (PyCFunction)MovieObj_UpdateMovie, 1,
     PyDoc_STR("() -> None")},
    {"InvalidateMovieRegion", (PyCFunction)MovieObj_InvalidateMovieRegion, 1,
     PyDoc_STR("(RgnHandle invalidRgn) -> None")},
    {"GetMovieBox", (PyCFunction)MovieObj_GetMovieBox, 1,
     PyDoc_STR("() -> (Rect boxRect)")},
    {"SetMovieBox", (PyCFunction)MovieObj_SetMovieBox, 1,
     PyDoc_STR("(Rect boxRect) -> None")},
    {"GetMovieDisplayClipRgn", (PyCFunction)MovieObj_GetMovieDisplayClipRgn, 1,
     PyDoc_STR("() -> (RgnHandle _rv)")},
    {"SetMovieDisplayClipRgn", (PyCFunction)MovieObj_SetMovieDisplayClipRgn, 1,
     PyDoc_STR("(RgnHandle theClip) -> None")},
    {"GetMovieClipRgn", (PyCFunction)MovieObj_GetMovieClipRgn, 1,
     PyDoc_STR("() -> (RgnHandle _rv)")},
    {"SetMovieClipRgn", (PyCFunction)MovieObj_SetMovieClipRgn, 1,
     PyDoc_STR("(RgnHandle theClip) -> None")},
    {"GetMovieDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieDisplayBoundsRgn, 1,
     PyDoc_STR("() -> (RgnHandle _rv)")},
    {"GetMovieBoundsRgn", (PyCFunction)MovieObj_GetMovieBoundsRgn, 1,
     PyDoc_STR("() -> (RgnHandle _rv)")},
    {"SetMovieVideoOutput", (PyCFunction)MovieObj_SetMovieVideoOutput, 1,
     PyDoc_STR("(ComponentInstance vout) -> None")},
    {"PutMovieIntoHandle", (PyCFunction)MovieObj_PutMovieIntoHandle, 1,
     PyDoc_STR("(Handle publicMovie) -> None")},
    {"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1,
     PyDoc_STR("(short fRefNum, long offset, long maxSize) -> None")},
    {"PutMovieIntoDataFork64", (PyCFunction)MovieObj_PutMovieIntoDataFork64, 1,
     PyDoc_STR("(long fRefNum, wide offset, unsigned long maxSize) -> None")},
    {"PutMovieIntoStorage", (PyCFunction)MovieObj_PutMovieIntoStorage, 1,
     PyDoc_STR("(DataHandler dh, wide offset, unsigned long maxSize) -> None")},
    {"PutMovieForDataRefIntoHandle", (PyCFunction)MovieObj_PutMovieForDataRefIntoHandle, 1,
     PyDoc_STR("(Handle dataRef, OSType dataRefType, Handle publicMovie) -> None")},
    {"GetMovieCreationTime", (PyCFunction)MovieObj_GetMovieCreationTime, 1,
     PyDoc_STR("() -> (unsigned long _rv)")},
    {"GetMovieModificationTime", (PyCFunction)MovieObj_GetMovieModificationTime, 1,
     PyDoc_STR("() -> (unsigned long _rv)")},
    {"GetMovieTimeScale", (PyCFunction)MovieObj_GetMovieTimeScale, 1,
     PyDoc_STR("() -> (TimeScale _rv)")},
    {"SetMovieTimeScale", (PyCFunction)MovieObj_SetMovieTimeScale, 1,
     PyDoc_STR("(TimeScale timeScale) -> None")},
    {"GetMovieDuration", (PyCFunction)MovieObj_GetMovieDuration, 1,
     PyDoc_STR("() -> (TimeValue _rv)")},
    {"GetMovieRate", (PyCFunction)MovieObj_GetMovieRate, 1,
     PyDoc_STR("() -> (Fixed _rv)")},
    {"SetMovieRate", (PyCFunction)MovieObj_SetMovieRate, 1,
     PyDoc_STR("(Fixed rate) -> None")},
    {"GetMoviePreferredRate", (PyCFunction)MovieObj_GetMoviePreferredRate, 1,
     PyDoc_STR("() -> (Fixed _rv)")},
    {"SetMoviePreferredRate", (PyCFunction)MovieObj_SetMoviePreferredRate, 1,
     PyDoc_STR("(Fixed rate) -> None")},
    {"GetMoviePreferredVolume", (PyCFunction)MovieObj_GetMoviePreferredVolume, 1,
     PyDoc_STR("() -> (short _rv)")},
    {"SetMoviePreferredVolume", (PyCFunction)MovieObj_SetMoviePreferredVolume, 1,
     PyDoc_STR("(short volume) -> None")},
    {"GetMovieVolume", (PyCFunction)MovieObj_GetMovieVolume, 1,
     PyDoc_STR("() -> (short _rv)")},
    {"SetMovieVolume", (PyCFunction)MovieObj_SetMovieVolume, 1,
     PyDoc_STR("(short volume) -> None")},
    {"GetMoviePreviewTime", (PyCFunction)MovieObj_GetMoviePreviewTime, 1,
     PyDoc_STR("() -> (TimeValue previewTime, TimeValue previewDuration)")},
    {"SetMoviePreviewTime", (PyCFunction)MovieObj_SetMoviePreviewTime, 1,
     PyDoc_STR("(TimeValue previewTime, TimeValue previewDuration) -> None")},
    {"GetMoviePosterTime", (PyCFunction)MovieObj_GetMoviePosterTime, 1,
     PyDoc_STR("() -> (TimeValue _rv)")},
    {"SetMoviePosterTime", (PyCFunction)MovieObj_SetMoviePosterTime, 1,
     PyDoc_STR("(TimeValue posterTime) -> None")},
    {"GetMovieSelection", (PyCFunction)MovieObj_GetMovieSelection, 1,
     PyDoc_STR("() -> (TimeValue selectionTime, TimeValue selectionDuration)")},
    {"SetMovieSelection", (PyCFunction)MovieObj_SetMovieSelection, 1,
     PyDoc_STR("(TimeValue selectionTime, TimeValue selectionDuration) -> None")},
    {"SetMovieActiveSegment", (PyCFunction)MovieObj_SetMovieActiveSegment, 1,
     PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")},
    {"GetMovieActiveSegment", (PyCFunction)MovieObj_GetMovieActiveSegment, 1,
     PyDoc_STR("() -> (TimeValue startTime, TimeValue duration)")},
    {"GetMovieTime", (PyCFunction)MovieObj_GetMovieTime, 1,
     PyDoc_STR("() -> (TimeValue _rv, TimeRecord currentTime)")},
    {"SetMovieTime", (PyCFunction)MovieObj_SetMovieTime, 1,
     PyDoc_STR("(TimeRecord newtime) -> None")},
    {"SetMovieTimeValue", (PyCFunction)MovieObj_SetMovieTimeValue, 1,
     PyDoc_STR("(TimeValue newtime) -> None")},
    {"GetMovieUserData", (PyCFunction)MovieObj_GetMovieUserData, 1,
     PyDoc_STR("() -> (UserData _rv)")},
    {"GetMovieTrackCount", (PyCFunction)MovieObj_GetMovieTrackCount, 1,
     PyDoc_STR("() -> (long _rv)")},
    {"GetMovieTrack", (PyCFunction)MovieObj_GetMovieTrack, 1,
     PyDoc_STR("(long trackID) -> (Track _rv)")},
    {"GetMovieIndTrack", (PyCFunction)MovieObj_GetMovieIndTrack, 1,
     PyDoc_STR("(long index) -> (Track _rv)")},
    {"GetMovieIndTrackType", (PyCFunction)MovieObj_GetMovieIndTrackType, 1,
     PyDoc_STR("(long index, OSType trackType, long flags) -> (Track _rv)")},
    {"NewMovieTrack", (PyCFunction)MovieObj_NewMovieTrack, 1,
     PyDoc_STR("(Fixed width, Fixed height, short trackVolume) -> (Track _rv)")},
    {"SetAutoTrackAlternatesEnabled", (PyCFunction)MovieObj_SetAutoTrackAlternatesEnabled, 1,
     PyDoc_STR("(Boolean enable) -> None")},
    {"SelectMovieAlternates", (PyCFunction)MovieObj_SelectMovieAlternates, 1,
     PyDoc_STR("() -> None")},
    {"InsertMovieSegment", (PyCFunction)MovieObj_InsertMovieSegment, 1,
     PyDoc_STR("(Movie dstMovie, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None")},
    {"InsertEmptyMovieSegment", (PyCFunction)MovieObj_InsertEmptyMovieSegment, 1,
     PyDoc_STR("(TimeValue dstIn, TimeValue dstDuration) -> None")},
    {"DeleteMovieSegment", (PyCFunction)MovieObj_DeleteMovieSegment, 1,
     PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")},
    {"ScaleMovieSegment", (PyCFunction)MovieObj_ScaleMovieSegment, 1,
     PyDoc_STR("(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None")},
    {"CutMovieSelection", (PyCFunction)MovieObj_CutMovieSelection, 1,
     PyDoc_STR("() -> (Movie _rv)")},
    {"CopyMovieSelection", (PyCFunction)MovieObj_CopyMovieSelection, 1,
     PyDoc_STR("() -> (Movie _rv)")},
    {"PasteMovieSelection", (PyCFunction)MovieObj_PasteMovieSelection, 1,
     PyDoc_STR("(Movie src) -> None")},
    {"AddMovieSelection", (PyCFunction)MovieObj_AddMovieSelection, 1,
     PyDoc_STR("(Movie src) -> None")},
    {"ClearMovieSelection", (PyCFunction)MovieObj_ClearMovieSelection, 1,
     PyDoc_STR("() -> None")},
    {"PutMovieIntoTypedHandle", (PyCFunction)MovieObj_PutMovieIntoTypedHandle, 1,
     PyDoc_STR("(Track targetTrack, OSType handleType, Handle publicMovie, TimeValue start, TimeValue dur, long flags, ComponentInstance userComp) -> None")},
    {"CopyMovieSettings", (PyCFunction)MovieObj_CopyMovieSettings, 1,
     PyDoc_STR("(Movie dstMovie) -> None")},
    {"ConvertMovieToFile", (PyCFunction)MovieObj_ConvertMovieToFile, 1,
     PyDoc_STR("(Track onlyTrack, FSSpec outputFile, OSType fileType, OSType creator, ScriptCode scriptTag, long flags, ComponentInstance userComp) -> (short resID)")},
    {"GetMovieDataSize", (PyCFunction)MovieObj_GetMovieDataSize, 1,
     PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")},
    {"GetMovieDataSize64", (PyCFunction)MovieObj_GetMovieDataSize64, 1,
     PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")},
    {"PtInMovie", (PyCFunction)MovieObj_PtInMovie, 1,
     PyDoc_STR("(Point pt) -> (Boolean _rv)")},
    {"SetMovieLanguage", (PyCFunction)MovieObj_SetMovieLanguage, 1,
     PyDoc_STR("(long language) -> None")},
    {"CopyMovieUserData", (PyCFunction)MovieObj_CopyMovieUserData, 1,
     PyDoc_STR("(Movie dstMovie, OSType copyRule) -> None")},
    {"GetMovieNextInterestingTime", (PyCFunction)MovieObj_GetMovieNextInterestingTime, 1,
     PyDoc_STR("(short interestingTimeFlags, short numMediaTypes, OSType whichMediaTypes, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
    {"AddMovieResource", (PyCFunction)MovieObj_AddMovieResource, 1,
     PyDoc_STR("(short resRefNum, Str255 resName) -> (short resId)")},
    {"UpdateMovieResource", (PyCFunction)MovieObj_UpdateMovieResource, 1,
     PyDoc_STR("(short resRefNum, short resId, Str255 resName) -> None")},
    {"AddMovieToStorage", (PyCFunction)MovieObj_AddMovieToStorage, 1,
     PyDoc_STR("(DataHandler dh) -> None")},
    {"UpdateMovieInStorage", (PyCFunction)MovieObj_UpdateMovieInStorage, 1,
     PyDoc_STR("(DataHandler dh) -> None")},
    {"HasMovieChanged", (PyCFunction)MovieObj_HasMovieChanged, 1,
     PyDoc_STR("() -> (Boolean _rv)")},
    {"ClearMovieChanged", (PyCFunction)MovieObj_ClearMovieChanged, 1,
     PyDoc_STR("() -> None")},
    {"SetMovieDefaultDataRef", (PyCFunction)MovieObj_SetMovieDefaultDataRef, 1,
     PyDoc_STR("(Handle dataRef, OSType dataRefType) -> None")},
    {"GetMovieDefaultDataRef", (PyCFunction)MovieObj_GetMovieDefaultDataRef, 1,
     PyDoc_STR("() -> (Handle dataRef, OSType dataRefType)")},
    {"SetMovieColorTable", (PyCFunction)MovieObj_SetMovieColorTable, 1,
     PyDoc_STR("(CTabHandle ctab) -> None")},
    {"GetMovieColorTable", (PyCFunction)MovieObj_GetMovieColorTable, 1,
     PyDoc_STR("() -> (CTabHandle ctab)")},
    {"FlattenMovie", (PyCFunction)MovieObj_FlattenMovie, 1,
     PyDoc_STR("(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Str255 resName) -> (short resId)")},
    {"FlattenMovieData", (PyCFunction)MovieObj_FlattenMovieData, 1,
     PyDoc_STR("(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)")},
    {"FlattenMovieDataToDataRef", (PyCFunction)MovieObj_FlattenMovieDataToDataRef, 1,
     PyDoc_STR("(long movieFlattenFlags, Handle dataRef, OSType dataRefType, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)")},
    {"MovieSearchText", (PyCFunction)MovieObj_MovieSearchText, 1,
     PyDoc_STR("(Ptr text, long size, long searchFlags) -> (Track searchTrack, TimeValue searchTime, long searchOffset)")},
    {"GetPosterBox", (PyCFunction)MovieObj_GetPosterBox, 1,
     PyDoc_STR("() -> (Rect boxRect)")},
    {"SetPosterBox", (PyCFunction)MovieObj_SetPosterBox, 1,
     PyDoc_STR("(Rect boxRect) -> None")},
    {"GetMovieSegmentDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieSegmentDisplayBoundsRgn, 1,
     PyDoc_STR("(TimeValue time, TimeValue duration) -> (RgnHandle _rv)")},
    {"GetMovieStatus", (PyCFunction)MovieObj_GetMovieStatus, 1,
     PyDoc_STR("() -> (ComponentResult _rv, Track firstProblemTrack)")},
    {"NewMovieController", (PyCFunction)MovieObj_NewMovieController, 1,
     PyDoc_STR("(Rect movieRect, long someFlags) -> (MovieController _rv)")},
    {"PutMovieOnScrap", (PyCFunction)MovieObj_PutMovieOnScrap, 1,
     PyDoc_STR("(long movieScrapFlags) -> None")},
    {"SetMoviePlayHints", (PyCFunction)MovieObj_SetMoviePlayHints, 1,
     PyDoc_STR("(long flags, long flagsMask) -> None")},
    {"GetMaxLoadedTimeInMovie", (PyCFunction)MovieObj_GetMaxLoadedTimeInMovie, 1,
     PyDoc_STR("() -> (TimeValue time)")},
    {"QTMovieNeedsTimeTable", (PyCFunction)MovieObj_QTMovieNeedsTimeTable, 1,
     PyDoc_STR("() -> (Boolean needsTimeTable)")},
    {"QTGetDataRefMaxFileOffset", (PyCFunction)MovieObj_QTGetDataRefMaxFileOffset, 1,
     PyDoc_STR("(OSType dataRefType, Handle dataRef) -> (long offset)")},
    {NULL, NULL, 0}
};

#define MovieObj_getsetlist NULL


#define MovieObj_compare NULL

#define MovieObj_repr NULL

#define MovieObj_hash NULL
#define MovieObj_tp_init 0

#define MovieObj_tp_alloc PyType_GenericAlloc

static PyObject *MovieObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
{
    PyObject *_self;
    Movie itself;
    char *kw[] = {"itself", 0};

    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, MovieObj_Convert, &itself)) return NULL;
    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    ((MovieObject *)_self)->ob_itself = itself;
    return _self;
}

#define MovieObj_tp_free PyObject_Del


PyTypeObject Movie_Type = {
    PyObject_HEAD_INIT(NULL)
    0, /*ob_size*/
    "_Qt.Movie", /*tp_name*/
    sizeof(MovieObject), /*tp_basicsize*/
    0, /*tp_itemsize*/
    /* methods */
    (destructor) MovieObj_dealloc, /*tp_dealloc*/
    0, /*tp_print*/
    (getattrfunc)0, /*tp_getattr*/
    (setattrfunc)0, /*tp_setattr*/
    (cmpfunc) MovieObj_compare, /*tp_compare*/
    (reprfunc) MovieObj_repr, /*tp_repr*/
    (PyNumberMethods *)0, /* tp_as_number */
    (PySequenceMethods *)0, /* tp_as_sequence */
    (PyMappingMethods *)0, /* tp_as_mapping */
    (hashfunc) MovieObj_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*/
    MovieObj_methods, /* tp_methods */
    0, /*tp_members*/
    MovieObj_getsetlist, /*tp_getset*/
    0, /*tp_base*/
    0, /*tp_dict*/
    0, /*tp_descr_get*/
    0, /*tp_descr_set*/
    0, /*tp_dictoffset*/
    MovieObj_tp_init, /* tp_init */
    MovieObj_tp_alloc, /* tp_alloc */
    MovieObj_tp_new, /* tp_new */
    MovieObj_tp_free, /* tp_free */
};

/* --------------------- End object type Movie ---------------------- */


/* ---------------------- Object type SGOutput ---------------------- */

PyTypeObject SGOutput_Type;

#define SGOutputObj_Check(x) ((x)->ob_type == &SGOutput_Type || PyObject_TypeCheck((x), &SGOutput_Type))

typedef struct SGOutputObject {
    PyObject_HEAD
    SGOutput ob_itself;
} SGOutputObject;

PyObject *SGOutputObj_New(SGOutput itself)
{
    SGOutputObject *it;
    if (itself == NULL) {
                                    PyErr_SetString(Qt_Error,"Cannot create SGOutput from NULL pointer");
                                    return NULL;
                            }
    it = PyObject_NEW(SGOutputObject, &SGOutput_Type);
    if (it == NULL) return NULL;
    it->ob_itself = itself;
    return (PyObject *)it;
}

int SGOutputObj_Convert(PyObject *v, SGOutput *p_itself)
{
    if (v == Py_None)
    {
        *p_itself = NULL;
        return 1;
    }
    if (!SGOutputObj_Check(v))
    {
        PyErr_SetString(PyExc_TypeError, "SGOutput required");
        return 0;
    }
    *p_itself = ((SGOutputObject *)v)->ob_itself;
    return 1;
}

static void SGOutputObj_dealloc(SGOutputObject *self)
{
    /* Cleanup of self->ob_itself goes here */
    self->ob_type->tp_free((PyObject *)self);
}

static PyMethodDef SGOutputObj_methods[] = {
    {NULL, NULL, 0}
};

#define SGOutputObj_getsetlist NULL


#define SGOutputObj_compare NULL

#define SGOutputObj_repr NULL

#define SGOutputObj_hash NULL
#define SGOutputObj_tp_init 0

#define SGOutputObj_tp_alloc PyType_GenericAlloc

static PyObject *SGOutputObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
{
    PyObject *_self;
    SGOutput itself;
    char *kw[] = {"itself", 0};

    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, SGOutputObj_Convert, &itself)) return NULL;
    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    ((SGOutputObject *)_self)->ob_itself = itself;
    return _self;
}

#define SGOutputObj_tp_free PyObject_Del


PyTypeObject SGOutput_Type = {
    PyObject_HEAD_INIT(NULL)
    0, /*ob_size*/
    "_Qt.SGOutput", /*tp_name*/
    sizeof(SGOutputObject), /*tp_basicsize*/
    0, /*tp_itemsize*/
    /* methods */
    (destructor) SGOutputObj_dealloc, /*tp_dealloc*/
    0, /*tp_print*/
    (getattrfunc)0, /*tp_getattr*/
    (setattrfunc)0, /*tp_setattr*/
    (cmpfunc) SGOutputObj_compare, /*tp_compare*/
    (reprfunc) SGOutputObj_repr, /*tp_repr*/
    (PyNumberMethods *)0, /* tp_as_number */
    (PySequenceMethods *)0, /* tp_as_sequence */
    (PyMappingMethods *)0, /* tp_as_mapping */
    (hashfunc) SGOutputObj_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*/
    SGOutputObj_methods, /* tp_methods */
    0, /*tp_members*/
    SGOutputObj_getsetlist, /*tp_getset*/
    0, /*tp_base*/
    0, /*tp_dict*/
    0, /*tp_descr_get*/
    0, /*tp_descr_set*/
    0, /*tp_dictoffset*/
    SGOutputObj_tp_init, /* tp_init */
    SGOutputObj_tp_alloc, /* tp_alloc */
    SGOutputObj_tp_new, /* tp_new */
    SGOutputObj_tp_free, /* tp_free */
};

/* -------------------- End object type SGOutput -------------------- */


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

static PyObject *Qt_ExitMovies(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
#ifndef ExitMovies
    PyMac_PRECHECK(ExitMovies);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    ExitMovies();
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

static PyObject *Qt_ClearMoviesStickyError(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
#ifndef ClearMoviesStickyError
    PyMac_PRECHECK(ClearMoviesStickyError);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    ClearMoviesStickyError();
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

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

static PyObject *Qt_QTGetWallClockTimeBase(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeBase wallClockTimeBase;
#ifndef QTGetWallClockTimeBase
    PyMac_PRECHECK(QTGetWallClockTimeBase);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = QTGetWallClockTimeBase(&wallClockTimeBase);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         TimeBaseObj_New, wallClockTimeBase);
    return _res;
}

static PyObject *Qt_QTIdleManagerOpen(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    IdleManager _rv;
#ifndef QTIdleManagerOpen
    PyMac_PRECHECK(QTIdleManagerOpen);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = QTIdleManagerOpen();
    _res = Py_BuildValue("O&",
                         IdleManagerObj_New, _rv);
    return _res;
}

static PyObject *Qt_CreateMovieControl(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    WindowPtr theWindow;
    Rect localRect;
    Movie theMovie;
    UInt32 options;
    ControlHandle returnedControl;
#ifndef CreateMovieControl
    PyMac_PRECHECK(CreateMovieControl);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          WinObj_Convert, &theWindow,
                          MovieObj_Convert, &theMovie,
                          &options))
        return NULL;
    _err = CreateMovieControl(theWindow,
                              &localRect,
                              theMovie,
                              options,
                              &returnedControl);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&O&",
                         PyMac_BuildRect, &localRect,
                         CtlObj_New, returnedControl);
    return _res;
}

static PyObject *Qt_DisposeMatte(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    PixMapHandle theMatte;
#ifndef DisposeMatte
    PyMac_PRECHECK(DisposeMatte);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &theMatte))
        return NULL;
    DisposeMatte(theMatte);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_NewMovie(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Movie _rv;
    long flags;
#ifndef NewMovie
    PyMac_PRECHECK(NewMovie);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &flags))
        return NULL;
    _rv = NewMovie(flags);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *Qt_QTGetTimeUntilNextTask(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    long duration;
    long scale;
#ifndef QTGetTimeUntilNextTask
    PyMac_PRECHECK(QTGetTimeUntilNextTask);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &scale))
        return NULL;
    _err = QTGetTimeUntilNextTask(&duration,
                                  scale);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         duration);
    return _res;
}

static PyObject *Qt_GetDataHandler(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Component _rv;
    Handle dataRef;
    OSType dataHandlerSubType;
    long flags;
#ifndef GetDataHandler
    PyMac_PRECHECK(GetDataHandler);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataHandlerSubType,
                          &flags))
        return NULL;
    _rv = GetDataHandler(dataRef,
                         dataHandlerSubType,
                         flags);
    _res = Py_BuildValue("O&",
                         CmpObj_New, _rv);
    return _res;
}

static PyObject *Qt_PasteHandleIntoMovie(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle h;
    OSType handleType;
    Movie theMovie;
    long flags;
    ComponentInstance userComp;
#ifndef PasteHandleIntoMovie
    PyMac_PRECHECK(PasteHandleIntoMovie);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&lO&",
                          ResObj_Convert, &h,
                          PyMac_GetOSType, &handleType,
                          MovieObj_Convert, &theMovie,
                          &flags,
                          CmpInstObj_Convert, &userComp))
        return NULL;
    _err = PasteHandleIntoMovie(h,
                                handleType,
                                theMovie,
                                flags,
                                userComp);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_GetMovieImporterForDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    OSType dataRefType;
    Handle dataRef;
    long flags;
    Component importer;
#ifndef GetMovieImporterForDataRef
    PyMac_PRECHECK(GetMovieImporterForDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          PyMac_GetOSType, &dataRefType,
                          ResObj_Convert, &dataRef,
                          &flags))
        return NULL;
    _err = GetMovieImporterForDataRef(dataRefType,
                                      dataRef,
                                      flags,
                                      &importer);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         CmpObj_New, importer);
    return _res;
}

static PyObject *Qt_QTGetMIMETypeInfo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    char* mimeStringStart;
    short mimeStringLength;
    OSType infoSelector;
    void * infoDataPtr;
    long infoDataSize;
#ifndef QTGetMIMETypeInfo
    PyMac_PRECHECK(QTGetMIMETypeInfo);
#endif
    if (!PyArg_ParseTuple(_args, "shO&s",
                          &mimeStringStart,
                          &mimeStringLength,
                          PyMac_GetOSType, &infoSelector,
                          &infoDataPtr))
        return NULL;
    _err = QTGetMIMETypeInfo(mimeStringStart,
                             mimeStringLength,
                             infoSelector,
                             infoDataPtr,
                             &infoDataSize);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         infoDataSize);
    return _res;
}

static PyObject *Qt_TrackTimeToMediaTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeValue _rv;
    TimeValue value;
    Track theTrack;
#ifndef TrackTimeToMediaTime
    PyMac_PRECHECK(TrackTimeToMediaTime);
#endif
    if (!PyArg_ParseTuple(_args, "lO&",
                          &value,
                          TrackObj_Convert, &theTrack))
        return NULL;
    _rv = TrackTimeToMediaTime(value,
                               theTrack);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_NewUserData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    UserData theUserData;
#ifndef NewUserData
    PyMac_PRECHECK(NewUserData);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = NewUserData(&theUserData);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         UserDataObj_New, theUserData);
    return _res;
}

static PyObject *Qt_NewUserDataFromHandle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle h;
    UserData theUserData;
#ifndef NewUserDataFromHandle
    PyMac_PRECHECK(NewUserDataFromHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &h))
        return NULL;
    _err = NewUserDataFromHandle(h,
                                 &theUserData);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         UserDataObj_New, theUserData);
    return _res;
}

static PyObject *Qt_CreateMovieFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    FSSpec fileSpec;
    OSType creator;
    ScriptCode scriptTag;
    long createMovieFileFlags;
    short resRefNum;
    Movie newmovie;
#ifndef CreateMovieFile
    PyMac_PRECHECK(CreateMovieFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&hl",
                          PyMac_GetFSSpec, &fileSpec,
                          PyMac_GetOSType, &creator,
                          &scriptTag,
                          &createMovieFileFlags))
        return NULL;
    _err = CreateMovieFile(&fileSpec,
                           creator,
                           scriptTag,
                           createMovieFileFlags,
                           &resRefNum,
                           &newmovie);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("hO&",
                         resRefNum,
                         MovieObj_New, newmovie);
    return _res;
}

static PyObject *Qt_OpenMovieFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    FSSpec fileSpec;
    short resRefNum;
    SInt8 permission;
#ifndef OpenMovieFile
    PyMac_PRECHECK(OpenMovieFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          PyMac_GetFSSpec, &fileSpec,
                          &permission))
        return NULL;
    _err = OpenMovieFile(&fileSpec,
                         &resRefNum,
                         permission);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         resRefNum);
    return _res;
}

static PyObject *Qt_CloseMovieFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    short resRefNum;
#ifndef CloseMovieFile
    PyMac_PRECHECK(CloseMovieFile);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &resRefNum))
        return NULL;
    _err = CloseMovieFile(resRefNum);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_DeleteMovieFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    FSSpec fileSpec;
#ifndef DeleteMovieFile
    PyMac_PRECHECK(DeleteMovieFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetFSSpec, &fileSpec))
        return NULL;
    _err = DeleteMovieFile(&fileSpec);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_NewMovieFromFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie theMovie;
    short resRefNum;
    short resId;
    short newMovieFlags;
    Boolean dataRefWasChanged;
#ifndef NewMovieFromFile
    PyMac_PRECHECK(NewMovieFromFile);
#endif
    if (!PyArg_ParseTuple(_args, "hhh",
                          &resRefNum,
                          &resId,
                          &newMovieFlags))
        return NULL;
    _err = NewMovieFromFile(&theMovie,
                            resRefNum,
                            &resId,
                            (StringPtr)0,
                            newMovieFlags,
                            &dataRefWasChanged);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&hb",
                         MovieObj_New, theMovie,
                         resId,
                         dataRefWasChanged);
    return _res;
}

static PyObject *Qt_NewMovieFromHandle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie theMovie;
    Handle h;
    short newMovieFlags;
    Boolean dataRefWasChanged;
#ifndef NewMovieFromHandle
    PyMac_PRECHECK(NewMovieFromHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          ResObj_Convert, &h,
                          &newMovieFlags))
        return NULL;
    _err = NewMovieFromHandle(&theMovie,
                              h,
                              newMovieFlags,
                              &dataRefWasChanged);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&b",
                         MovieObj_New, theMovie,
                         dataRefWasChanged);
    return _res;
}

static PyObject *Qt_NewMovieFromDataFork(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie theMovie;
    short fRefNum;
    long fileOffset;
    short newMovieFlags;
    Boolean dataRefWasChanged;
#ifndef NewMovieFromDataFork
    PyMac_PRECHECK(NewMovieFromDataFork);
#endif
    if (!PyArg_ParseTuple(_args, "hlh",
                          &fRefNum,
                          &fileOffset,
                          &newMovieFlags))
        return NULL;
    _err = NewMovieFromDataFork(&theMovie,
                                fRefNum,
                                fileOffset,
                                newMovieFlags,
                                &dataRefWasChanged);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&b",
                         MovieObj_New, theMovie,
                         dataRefWasChanged);
    return _res;
}

static PyObject *Qt_NewMovieFromDataFork64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie theMovie;
    long fRefNum;
    wide fileOffset;
    short newMovieFlags;
    Boolean dataRefWasChanged;
#ifndef NewMovieFromDataFork64
    PyMac_PRECHECK(NewMovieFromDataFork64);
#endif
    if (!PyArg_ParseTuple(_args, "lO&h",
                          &fRefNum,
                          PyMac_Getwide, &fileOffset,
                          &newMovieFlags))
        return NULL;
    _err = NewMovieFromDataFork64(&theMovie,
                                  fRefNum,
                                  &fileOffset,
                                  newMovieFlags,
                                  &dataRefWasChanged);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&b",
                         MovieObj_New, theMovie,
                         dataRefWasChanged);
    return _res;
}

static PyObject *Qt_NewMovieFromDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie m;
    short flags;
    short id;
    Handle dataRef;
    OSType dtaRefType;
#ifndef NewMovieFromDataRef
    PyMac_PRECHECK(NewMovieFromDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "hO&O&",
                          &flags,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dtaRefType))
        return NULL;
    _err = NewMovieFromDataRef(&m,
                               flags,
                               &id,
                               dataRef,
                               dtaRefType);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&h",
                         MovieObj_New, m,
                         id);
    return _res;
}

static PyObject *Qt_NewMovieFromStorageOffset(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie theMovie;
    DataHandler dh;
    wide fileOffset;
    short newMovieFlags;
    Boolean dataRefWasCataRefType;
#ifndef NewMovieFromStorageOffset
    PyMac_PRECHECK(NewMovieFromStorageOffset);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&h",
                          CmpInstObj_Convert, &dh,
                          PyMac_Getwide, &fileOffset,
                          &newMovieFlags))
        return NULL;
    _err = NewMovieFromStorageOffset(&theMovie,
                                     dh,
                                     &fileOffset,
                                     newMovieFlags,
                                     &dataRefWasCataRefType);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&b",
                         MovieObj_New, theMovie,
                         dataRefWasCataRefType);
    return _res;
}

static PyObject *Qt_NewMovieForDataRefFromHandle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie theMovie;
    Handle h;
    short newMovieFlags;
    Boolean dataRefWasChanged;
    Handle dataRef;
    OSType dataRefType;
#ifndef NewMovieForDataRefFromHandle
    PyMac_PRECHECK(NewMovieForDataRefFromHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&hO&O&",
                          ResObj_Convert, &h,
                          &newMovieFlags,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _err = NewMovieForDataRefFromHandle(&theMovie,
                                        h,
                                        newMovieFlags,
                                        &dataRefWasChanged,
                                        dataRef,
                                        dataRefType);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&b",
                         MovieObj_New, theMovie,
                         dataRefWasChanged);
    return _res;
}

static PyObject *Qt_RemoveMovieResource(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    short resRefNum;
    short resId;
#ifndef RemoveMovieResource
    PyMac_PRECHECK(RemoveMovieResource);
#endif
    if (!PyArg_ParseTuple(_args, "hh",
                          &resRefNum,
                          &resId))
        return NULL;
    _err = RemoveMovieResource(resRefNum,
                               resId);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_CreateMovieStorage(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataRef;
    OSType dataRefType;
    OSType creator;
    ScriptCode scriptTag;
    long createMovieFileFlags;
    DataHandler outDataHandler;
    Movie newmovie;
#ifndef CreateMovieStorage
    PyMac_PRECHECK(CreateMovieStorage);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&hl",
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType,
                          PyMac_GetOSType, &creator,
                          &scriptTag,
                          &createMovieFileFlags))
        return NULL;
    _err = CreateMovieStorage(dataRef,
                              dataRefType,
                              creator,
                              scriptTag,
                              createMovieFileFlags,
                              &outDataHandler,
                              &newmovie);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&O&",
                         CmpInstObj_New, outDataHandler,
                         MovieObj_New, newmovie);
    return _res;
}

static PyObject *Qt_OpenMovieStorage(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataRef;
    OSType dataRefType;
    long flags;
    DataHandler outDataHandler;
#ifndef OpenMovieStorage
    PyMac_PRECHECK(OpenMovieStorage);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType,
                          &flags))
        return NULL;
    _err = OpenMovieStorage(dataRef,
                            dataRefType,
                            flags,
                            &outDataHandler);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         CmpInstObj_New, outDataHandler);
    return _res;
}

static PyObject *Qt_CloseMovieStorage(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    DataHandler dh;
#ifndef CloseMovieStorage
    PyMac_PRECHECK(CloseMovieStorage);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _err = CloseMovieStorage(dh);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_DeleteMovieStorage(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataRef;
    OSType dataRefType;
#ifndef DeleteMovieStorage
    PyMac_PRECHECK(DeleteMovieStorage);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _err = DeleteMovieStorage(dataRef,
                              dataRefType);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_CreateShortcutMovieFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    FSSpec fileSpec;
    OSType creator;
    ScriptCode scriptTag;
    long createMovieFileFlags;
    Handle targetDataRef;
    OSType targetDataRefType;
#ifndef CreateShortcutMovieFile
    PyMac_PRECHECK(CreateShortcutMovieFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&hlO&O&",
                          PyMac_GetFSSpec, &fileSpec,
                          PyMac_GetOSType, &creator,
                          &scriptTag,
                          &createMovieFileFlags,
                          ResObj_Convert, &targetDataRef,
                          PyMac_GetOSType, &targetDataRefType))
        return NULL;
    _err = CreateShortcutMovieFile(&fileSpec,
                                   creator,
                                   scriptTag,
                                   createMovieFileFlags,
                                   targetDataRef,
                                   targetDataRefType);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_CanQuickTimeOpenFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    FSSpec fileSpec;
    OSType fileType;
    OSType fileNameExtension;
    Boolean outCanOpenWithGraphicsImporter;
    Boolean outCanOpenAsMovie;
    Boolean outPreferGraphicsImporter;
    UInt32 inFlags;
#ifndef CanQuickTimeOpenFile
    PyMac_PRECHECK(CanQuickTimeOpenFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&l",
                          PyMac_GetFSSpec, &fileSpec,
                          PyMac_GetOSType, &fileType,
                          PyMac_GetOSType, &fileNameExtension,
                          &inFlags))
        return NULL;
    _err = CanQuickTimeOpenFile(&fileSpec,
                                fileType,
                                fileNameExtension,
                                &outCanOpenWithGraphicsImporter,
                                &outCanOpenAsMovie,
                                &outPreferGraphicsImporter,
                                inFlags);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("bbb",
                         outCanOpenWithGraphicsImporter,
                         outCanOpenAsMovie,
                         outPreferGraphicsImporter);
    return _res;
}

static PyObject *Qt_CanQuickTimeOpenDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataRef;
    OSType dataRefType;
    Boolean outCanOpenWithGraphicsImporter;
    Boolean outCanOpenAsMovie;
    Boolean outPreferGraphicsImporter;
    UInt32 inFlags;
#ifndef CanQuickTimeOpenDataRef
    PyMac_PRECHECK(CanQuickTimeOpenDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType,
                          &inFlags))
        return NULL;
    _err = CanQuickTimeOpenDataRef(dataRef,
                                   dataRefType,
                                   &outCanOpenWithGraphicsImporter,
                                   &outCanOpenAsMovie,
                                   &outPreferGraphicsImporter,
                                   inFlags);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("bbb",
                         outCanOpenWithGraphicsImporter,
                         outCanOpenAsMovie,
                         outPreferGraphicsImporter);
    return _res;
}

static PyObject *Qt_NewMovieFromScrap(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Movie _rv;
    long newMovieFlags;
#ifndef NewMovieFromScrap
    PyMac_PRECHECK(NewMovieFromScrap);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &newMovieFlags))
        return NULL;
    _rv = NewMovieFromScrap(newMovieFlags);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *Qt_QTNewAlias(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    FSSpec fss;
    AliasHandle alias;
    Boolean minimal;
#ifndef QTNewAlias
    PyMac_PRECHECK(QTNewAlias);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          PyMac_GetFSSpec, &fss,
                          &minimal))
        return NULL;
    _err = QTNewAlias(&fss,
                      &alias,
                      minimal);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         ResObj_New, alias);
    return _res;
}

static PyObject *Qt_EndFullScreen(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Ptr fullState;
    long flags;
#ifndef EndFullScreen
    PyMac_PRECHECK(EndFullScreen);
#endif
    if (!PyArg_ParseTuple(_args, "sl",
                          &fullState,
                          &flags))
        return NULL;
    _err = EndFullScreen(fullState,
                         flags);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_AddSoundDescriptionExtension(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SoundDescriptionHandle desc;
    Handle extension;
    OSType idType;
#ifndef AddSoundDescriptionExtension
    PyMac_PRECHECK(AddSoundDescriptionExtension);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          ResObj_Convert, &desc,
                          ResObj_Convert, &extension,
                          PyMac_GetOSType, &idType))
        return NULL;
    _err = AddSoundDescriptionExtension(desc,
                                        extension,
                                        idType);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_GetSoundDescriptionExtension(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SoundDescriptionHandle desc;
    Handle extension;
    OSType idType;
#ifndef GetSoundDescriptionExtension
    PyMac_PRECHECK(GetSoundDescriptionExtension);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &desc,
                          PyMac_GetOSType, &idType))
        return NULL;
    _err = GetSoundDescriptionExtension(desc,
                                        &extension,
                                        idType);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         ResObj_New, extension);
    return _res;
}

static PyObject *Qt_RemoveSoundDescriptionExtension(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SoundDescriptionHandle desc;
    OSType idType;
#ifndef RemoveSoundDescriptionExtension
    PyMac_PRECHECK(RemoveSoundDescriptionExtension);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &desc,
                          PyMac_GetOSType, &idType))
        return NULL;
    _err = RemoveSoundDescriptionExtension(desc,
                                           idType);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_QTIsStandardParameterDialogEvent(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    EventRecord pEvent;
    QTParameterDialog createdDialog;
#ifndef QTIsStandardParameterDialogEvent
    PyMac_PRECHECK(QTIsStandardParameterDialogEvent);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &createdDialog))
        return NULL;
    _err = QTIsStandardParameterDialogEvent(&pEvent,
                                            createdDialog);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         PyMac_BuildEventRecord, &pEvent);
    return _res;
}

static PyObject *Qt_QTDismissStandardParameterDialog(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    QTParameterDialog createdDialog;
#ifndef QTDismissStandardParameterDialog
    PyMac_PRECHECK(QTDismissStandardParameterDialog);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &createdDialog))
        return NULL;
    _err = QTDismissStandardParameterDialog(createdDialog);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_QTStandardParameterDialogDoAction(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    QTParameterDialog createdDialog;
    long action;
    void * params;
#ifndef QTStandardParameterDialogDoAction
    PyMac_PRECHECK(QTStandardParameterDialogDoAction);
#endif
    if (!PyArg_ParseTuple(_args, "lls",
                          &createdDialog,
                          &action,
                          &params))
        return NULL;
    _err = QTStandardParameterDialogDoAction(createdDialog,
                                             action,
                                             params);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_QTRegisterAccessKey(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Str255 accessKeyType;
    long flags;
    Handle accessKey;
#ifndef QTRegisterAccessKey
    PyMac_PRECHECK(QTRegisterAccessKey);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          PyMac_GetStr255, accessKeyType,
                          &flags,
                          ResObj_Convert, &accessKey))
        return NULL;
    _err = QTRegisterAccessKey(accessKeyType,
                               flags,
                               accessKey);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_QTUnregisterAccessKey(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Str255 accessKeyType;
    long flags;
    Handle accessKey;
#ifndef QTUnregisterAccessKey
    PyMac_PRECHECK(QTUnregisterAccessKey);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          PyMac_GetStr255, accessKeyType,
                          &flags,
                          ResObj_Convert, &accessKey))
        return NULL;
    _err = QTUnregisterAccessKey(accessKeyType,
                                 flags,
                                 accessKey);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_QTGetSupportedRestrictions(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    OSType inRestrictionClass;
    UInt32 outRestrictionIDs;
#ifndef QTGetSupportedRestrictions
    PyMac_PRECHECK(QTGetSupportedRestrictions);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetOSType, &inRestrictionClass))
        return NULL;
    _err = QTGetSupportedRestrictions(inRestrictionClass,
                                      &outRestrictionIDs);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         outRestrictionIDs);
    return _res;
}

static PyObject *Qt_QTTextToNativeText(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle theText;
    long encoding;
    long flags;
#ifndef QTTextToNativeText
    PyMac_PRECHECK(QTTextToNativeText);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          ResObj_Convert, &theText,
                          &encoding,
                          &flags))
        return NULL;
    _err = QTTextToNativeText(theText,
                              encoding,
                              flags);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_VideoMediaResetStatistics(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
#ifndef VideoMediaResetStatistics
    PyMac_PRECHECK(VideoMediaResetStatistics);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = VideoMediaResetStatistics(mh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VideoMediaGetStatistics(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
#ifndef VideoMediaGetStatistics
    PyMac_PRECHECK(VideoMediaGetStatistics);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = VideoMediaGetStatistics(mh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VideoMediaGetStallCount(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    unsigned long stalls;
#ifndef VideoMediaGetStallCount
    PyMac_PRECHECK(VideoMediaGetStallCount);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = VideoMediaGetStallCount(mh,
                                  &stalls);
    _res = Py_BuildValue("ll",
                         _rv,
                         stalls);
    return _res;
}

static PyObject *Qt_VideoMediaSetCodecParameter(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    CodecType cType;
    OSType parameterID;
    long parameterChangeSeed;
    void * dataPtr;
    long dataSize;
#ifndef VideoMediaSetCodecParameter
    PyMac_PRECHECK(VideoMediaSetCodecParameter);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&lsl",
                          CmpInstObj_Convert, &mh,
                          PyMac_GetOSType, &cType,
                          PyMac_GetOSType, &parameterID,
                          &parameterChangeSeed,
                          &dataPtr,
                          &dataSize))
        return NULL;
    _rv = VideoMediaSetCodecParameter(mh,
                                      cType,
                                      parameterID,
                                      parameterChangeSeed,
                                      dataPtr,
                                      dataSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VideoMediaGetCodecParameter(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    CodecType cType;
    OSType parameterID;
    Handle outParameterData;
#ifndef VideoMediaGetCodecParameter
    PyMac_PRECHECK(VideoMediaGetCodecParameter);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&",
                          CmpInstObj_Convert, &mh,
                          PyMac_GetOSType, &cType,
                          PyMac_GetOSType, &parameterID,
                          ResObj_Convert, &outParameterData))
        return NULL;
    _rv = VideoMediaGetCodecParameter(mh,
                                      cType,
                                      parameterID,
                                      outParameterData);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TextMediaAddTextSample(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Ptr text;
    unsigned long size;
    short fontNumber;
    short fontSize;
    Style textFace;
    RGBColor textColor;
    RGBColor backColor;
    short textJustification;
    Rect textBox;
    long displayFlags;
    TimeValue scrollDelay;
    short hiliteStart;
    short hiliteEnd;
    RGBColor rgbHiliteColor;
    TimeValue duration;
    TimeValue sampleTime;
#ifndef TextMediaAddTextSample
    PyMac_PRECHECK(TextMediaAddTextSample);
#endif
    if (!PyArg_ParseTuple(_args, "O&slhhbhllhhl",
                          CmpInstObj_Convert, &mh,
                          &text,
                          &size,
                          &fontNumber,
                          &fontSize,
                          &textFace,
                          &textJustification,
                          &displayFlags,
                          &scrollDelay,
                          &hiliteStart,
                          &hiliteEnd,
                          &duration))
        return NULL;
    _rv = TextMediaAddTextSample(mh,
                                 text,
                                 size,
                                 fontNumber,
                                 fontSize,
                                 textFace,
                                 &textColor,
                                 &backColor,
                                 textJustification,
                                 &textBox,
                                 displayFlags,
                                 scrollDelay,
                                 hiliteStart,
                                 hiliteEnd,
                                 &rgbHiliteColor,
                                 duration,
                                 &sampleTime);
    _res = Py_BuildValue("lO&O&O&O&l",
                         _rv,
                         QdRGB_New, &textColor,
                         QdRGB_New, &backColor,
                         PyMac_BuildRect, &textBox,
                         QdRGB_New, &rgbHiliteColor,
                         sampleTime);
    return _res;
}

static PyObject *Qt_TextMediaAddTESample(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    TEHandle hTE;
    RGBColor backColor;
    short textJustification;
    Rect textBox;
    long displayFlags;
    TimeValue scrollDelay;
    short hiliteStart;
    short hiliteEnd;
    RGBColor rgbHiliteColor;
    TimeValue duration;
    TimeValue sampleTime;
#ifndef TextMediaAddTESample
    PyMac_PRECHECK(TextMediaAddTESample);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&hllhhl",
                          CmpInstObj_Convert, &mh,
                          ResObj_Convert, &hTE,
                          &textJustification,
                          &displayFlags,
                          &scrollDelay,
                          &hiliteStart,
                          &hiliteEnd,
                          &duration))
        return NULL;
    _rv = TextMediaAddTESample(mh,
                               hTE,
                               &backColor,
                               textJustification,
                               &textBox,
                               displayFlags,
                               scrollDelay,
                               hiliteStart,
                               hiliteEnd,
                               &rgbHiliteColor,
                               duration,
                               &sampleTime);
    _res = Py_BuildValue("lO&O&O&l",
                         _rv,
                         QdRGB_New, &backColor,
                         PyMac_BuildRect, &textBox,
                         QdRGB_New, &rgbHiliteColor,
                         sampleTime);
    return _res;
}

static PyObject *Qt_TextMediaAddHiliteSample(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short hiliteStart;
    short hiliteEnd;
    RGBColor rgbHiliteColor;
    TimeValue duration;
    TimeValue sampleTime;
#ifndef TextMediaAddHiliteSample
    PyMac_PRECHECK(TextMediaAddHiliteSample);
#endif
    if (!PyArg_ParseTuple(_args, "O&hhl",
                          CmpInstObj_Convert, &mh,
                          &hiliteStart,
                          &hiliteEnd,
                          &duration))
        return NULL;
    _rv = TextMediaAddHiliteSample(mh,
                                   hiliteStart,
                                   hiliteEnd,
                                   &rgbHiliteColor,
                                   duration,
                                   &sampleTime);
    _res = Py_BuildValue("lO&l",
                         _rv,
                         QdRGB_New, &rgbHiliteColor,
                         sampleTime);
    return _res;
}

static PyObject *Qt_TextMediaDrawRaw(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    GWorldPtr gw;
    GDHandle gd;
    void * data;
    long dataSize;
    TextDescriptionHandle tdh;
#ifndef TextMediaDrawRaw
    PyMac_PRECHECK(TextMediaDrawRaw);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&slO&",
                          CmpInstObj_Convert, &mh,
                          GWorldObj_Convert, &gw,
                          OptResObj_Convert, &gd,
                          &data,
                          &dataSize,
                          ResObj_Convert, &tdh))
        return NULL;
    _rv = TextMediaDrawRaw(mh,
                           gw,
                           gd,
                           data,
                           dataSize,
                           tdh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TextMediaSetTextProperty(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    TimeValue atMediaTime;
    long propertyType;
    void * data;
    long dataSize;
#ifndef TextMediaSetTextProperty
    PyMac_PRECHECK(TextMediaSetTextProperty);
#endif
    if (!PyArg_ParseTuple(_args, "O&llsl",
                          CmpInstObj_Convert, &mh,
                          &atMediaTime,
                          &propertyType,
                          &data,
                          &dataSize))
        return NULL;
    _rv = TextMediaSetTextProperty(mh,
                                   atMediaTime,
                                   propertyType,
                                   data,
                                   dataSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TextMediaRawSetup(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    GWorldPtr gw;
    GDHandle gd;
    void * data;
    long dataSize;
    TextDescriptionHandle tdh;
    TimeValue sampleDuration;
#ifndef TextMediaRawSetup
    PyMac_PRECHECK(TextMediaRawSetup);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&slO&l",
                          CmpInstObj_Convert, &mh,
                          GWorldObj_Convert, &gw,
                          OptResObj_Convert, &gd,
                          &data,
                          &dataSize,
                          ResObj_Convert, &tdh,
                          &sampleDuration))
        return NULL;
    _rv = TextMediaRawSetup(mh,
                            gw,
                            gd,
                            data,
                            dataSize,
                            tdh,
                            sampleDuration);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TextMediaRawIdle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    GWorldPtr gw;
    GDHandle gd;
    TimeValue sampleTime;
    long flagsIn;
    long flagsOut;
#ifndef TextMediaRawIdle
    PyMac_PRECHECK(TextMediaRawIdle);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&ll",
                          CmpInstObj_Convert, &mh,
                          GWorldObj_Convert, &gw,
                          OptResObj_Convert, &gd,
                          &sampleTime,
                          &flagsIn))
        return NULL;
    _rv = TextMediaRawIdle(mh,
                           gw,
                           gd,
                           sampleTime,
                           flagsIn,
                           &flagsOut);
    _res = Py_BuildValue("ll",
                         _rv,
                         flagsOut);
    return _res;
}

static PyObject *Qt_TextMediaGetTextProperty(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    TimeValue atMediaTime;
    long propertyType;
    void * data;
    long dataSize;
#ifndef TextMediaGetTextProperty
    PyMac_PRECHECK(TextMediaGetTextProperty);
#endif
    if (!PyArg_ParseTuple(_args, "O&llsl",
                          CmpInstObj_Convert, &mh,
                          &atMediaTime,
                          &propertyType,
                          &data,
                          &dataSize))
        return NULL;
    _rv = TextMediaGetTextProperty(mh,
                                   atMediaTime,
                                   propertyType,
                                   data,
                                   dataSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TextMediaFindNextText(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Ptr text;
    long size;
    short findFlags;
    TimeValue startTime;
    TimeValue foundTime;
    TimeValue foundDuration;
    long offset;
#ifndef TextMediaFindNextText
    PyMac_PRECHECK(TextMediaFindNextText);
#endif
    if (!PyArg_ParseTuple(_args, "O&slhl",
                          CmpInstObj_Convert, &mh,
                          &text,
                          &size,
                          &findFlags,
                          &startTime))
        return NULL;
    _rv = TextMediaFindNextText(mh,
                                text,
                                size,
                                findFlags,
                                startTime,
                                &foundTime,
                                &foundDuration,
                                &offset);
    _res = Py_BuildValue("llll",
                         _rv,
                         foundTime,
                         foundDuration,
                         offset);
    return _res;
}

static PyObject *Qt_TextMediaHiliteTextSample(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    TimeValue sampleTime;
    short hiliteStart;
    short hiliteEnd;
    RGBColor rgbHiliteColor;
#ifndef TextMediaHiliteTextSample
    PyMac_PRECHECK(TextMediaHiliteTextSample);
#endif
    if (!PyArg_ParseTuple(_args, "O&lhh",
                          CmpInstObj_Convert, &mh,
                          &sampleTime,
                          &hiliteStart,
                          &hiliteEnd))
        return NULL;
    _rv = TextMediaHiliteTextSample(mh,
                                    sampleTime,
                                    hiliteStart,
                                    hiliteEnd,
                                    &rgbHiliteColor);
    _res = Py_BuildValue("lO&",
                         _rv,
                         QdRGB_New, &rgbHiliteColor);
    return _res;
}

static PyObject *Qt_TextMediaSetTextSampleData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    void * data;
    OSType dataType;
#ifndef TextMediaSetTextSampleData
    PyMac_PRECHECK(TextMediaSetTextSampleData);
#endif
    if (!PyArg_ParseTuple(_args, "O&sO&",
                          CmpInstObj_Convert, &mh,
                          &data,
                          PyMac_GetOSType, &dataType))
        return NULL;
    _rv = TextMediaSetTextSampleData(mh,
                                     data,
                                     dataType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SpriteMediaSetProperty(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short spriteIndex;
    long propertyType;
    void * propertyValue;
#ifndef SpriteMediaSetProperty
    PyMac_PRECHECK(SpriteMediaSetProperty);
#endif
    if (!PyArg_ParseTuple(_args, "O&hls",
                          CmpInstObj_Convert, &mh,
                          &spriteIndex,
                          &propertyType,
                          &propertyValue))
        return NULL;
    _rv = SpriteMediaSetProperty(mh,
                                 spriteIndex,
                                 propertyType,
                                 propertyValue);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SpriteMediaGetProperty(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short spriteIndex;
    long propertyType;
    void * propertyValue;
#ifndef SpriteMediaGetProperty
    PyMac_PRECHECK(SpriteMediaGetProperty);
#endif
    if (!PyArg_ParseTuple(_args, "O&hls",
                          CmpInstObj_Convert, &mh,
                          &spriteIndex,
                          &propertyType,
                          &propertyValue))
        return NULL;
    _rv = SpriteMediaGetProperty(mh,
                                 spriteIndex,
                                 propertyType,
                                 propertyValue);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SpriteMediaHitTestSprites(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long flags;
    Point loc;
    short spriteHitIndex;
#ifndef SpriteMediaHitTestSprites
    PyMac_PRECHECK(SpriteMediaHitTestSprites);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          CmpInstObj_Convert, &mh,
                          &flags,
                          PyMac_GetPoint, &loc))
        return NULL;
    _rv = SpriteMediaHitTestSprites(mh,
                                    flags,
                                    loc,
                                    &spriteHitIndex);
    _res = Py_BuildValue("lh",
                         _rv,
                         spriteHitIndex);
    return _res;
}

static PyObject *Qt_SpriteMediaCountSprites(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short numSprites;
#ifndef SpriteMediaCountSprites
    PyMac_PRECHECK(SpriteMediaCountSprites);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = SpriteMediaCountSprites(mh,
                                  &numSprites);
    _res = Py_BuildValue("lh",
                         _rv,
                         numSprites);
    return _res;
}

static PyObject *Qt_SpriteMediaCountImages(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short numImages;
#ifndef SpriteMediaCountImages
    PyMac_PRECHECK(SpriteMediaCountImages);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = SpriteMediaCountImages(mh,
                                 &numImages);
    _res = Py_BuildValue("lh",
                         _rv,
                         numImages);
    return _res;
}

static PyObject *Qt_SpriteMediaGetIndImageDescription(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short imageIndex;
    ImageDescriptionHandle imageDescription;
#ifndef SpriteMediaGetIndImageDescription
    PyMac_PRECHECK(SpriteMediaGetIndImageDescription);
#endif
    if (!PyArg_ParseTuple(_args, "O&hO&",
                          CmpInstObj_Convert, &mh,
                          &imageIndex,
                          ResObj_Convert, &imageDescription))
        return NULL;
    _rv = SpriteMediaGetIndImageDescription(mh,
                                            imageIndex,
                                            imageDescription);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SpriteMediaGetDisplayedSampleNumber(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long sampleNum;
#ifndef SpriteMediaGetDisplayedSampleNumber
    PyMac_PRECHECK(SpriteMediaGetDisplayedSampleNumber);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = SpriteMediaGetDisplayedSampleNumber(mh,
                                              &sampleNum);
    _res = Py_BuildValue("ll",
                         _rv,
                         sampleNum);
    return _res;
}

static PyObject *Qt_SpriteMediaGetSpriteName(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    QTAtomID spriteID;
    Str255 spriteName;
#ifndef SpriteMediaGetSpriteName
    PyMac_PRECHECK(SpriteMediaGetSpriteName);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          CmpInstObj_Convert, &mh,
                          &spriteID,
                          PyMac_GetStr255, spriteName))
        return NULL;
    _rv = SpriteMediaGetSpriteName(mh,
                                   spriteID,
                                   spriteName);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SpriteMediaGetImageName(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short imageIndex;
    Str255 imageName;
#ifndef SpriteMediaGetImageName
    PyMac_PRECHECK(SpriteMediaGetImageName);
#endif
    if (!PyArg_ParseTuple(_args, "O&hO&",
                          CmpInstObj_Convert, &mh,
                          &imageIndex,
                          PyMac_GetStr255, imageName))
        return NULL;
    _rv = SpriteMediaGetImageName(mh,
                                  imageIndex,
                                  imageName);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SpriteMediaSetSpriteProperty(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    QTAtomID spriteID;
    long propertyType;
    void * propertyValue;
#ifndef SpriteMediaSetSpriteProperty
    PyMac_PRECHECK(SpriteMediaSetSpriteProperty);
#endif
    if (!PyArg_ParseTuple(_args, "O&lls",
                          CmpInstObj_Convert, &mh,
                          &spriteID,
                          &propertyType,
                          &propertyValue))
        return NULL;
    _rv = SpriteMediaSetSpriteProperty(mh,
                                       spriteID,
                                       propertyType,
                                       propertyValue);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SpriteMediaGetSpriteProperty(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    QTAtomID spriteID;
    long propertyType;
    void * propertyValue;
#ifndef SpriteMediaGetSpriteProperty
    PyMac_PRECHECK(SpriteMediaGetSpriteProperty);
#endif
    if (!PyArg_ParseTuple(_args, "O&lls",
                          CmpInstObj_Convert, &mh,
                          &spriteID,
                          &propertyType,
                          &propertyValue))
        return NULL;
    _rv = SpriteMediaGetSpriteProperty(mh,
                                       spriteID,
                                       propertyType,
                                       propertyValue);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SpriteMediaHitTestAllSprites(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long flags;
    Point loc;
    QTAtomID spriteHitID;
#ifndef SpriteMediaHitTestAllSprites
    PyMac_PRECHECK(SpriteMediaHitTestAllSprites);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          CmpInstObj_Convert, &mh,
                          &flags,
                          PyMac_GetPoint, &loc))
        return NULL;
    _rv = SpriteMediaHitTestAllSprites(mh,
                                       flags,
                                       loc,
                                       &spriteHitID);
    _res = Py_BuildValue("ll",
                         _rv,
                         spriteHitID);
    return _res;
}

static PyObject *Qt_SpriteMediaHitTestOneSprite(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    QTAtomID spriteID;
    long flags;
    Point loc;
    Boolean wasHit;
#ifndef SpriteMediaHitTestOneSprite
    PyMac_PRECHECK(SpriteMediaHitTestOneSprite);
#endif
    if (!PyArg_ParseTuple(_args, "O&llO&",
                          CmpInstObj_Convert, &mh,
                          &spriteID,
                          &flags,
                          PyMac_GetPoint, &loc))
        return NULL;
    _rv = SpriteMediaHitTestOneSprite(mh,
                                      spriteID,
                                      flags,
                                      loc,
                                      &wasHit);
    _res = Py_BuildValue("lb",
                         _rv,
                         wasHit);
    return _res;
}

static PyObject *Qt_SpriteMediaSpriteIndexToID(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short spriteIndex;
    QTAtomID spriteID;
#ifndef SpriteMediaSpriteIndexToID
    PyMac_PRECHECK(SpriteMediaSpriteIndexToID);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &mh,
                          &spriteIndex))
        return NULL;
    _rv = SpriteMediaSpriteIndexToID(mh,
                                     spriteIndex,
                                     &spriteID);
    _res = Py_BuildValue("ll",
                         _rv,
                         spriteID);
    return _res;
}

static PyObject *Qt_SpriteMediaSpriteIDToIndex(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    QTAtomID spriteID;
    short spriteIndex;
#ifndef SpriteMediaSpriteIDToIndex
    PyMac_PRECHECK(SpriteMediaSpriteIDToIndex);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &spriteID))
        return NULL;
    _rv = SpriteMediaSpriteIDToIndex(mh,
                                     spriteID,
                                     &spriteIndex);
    _res = Py_BuildValue("lh",
                         _rv,
                         spriteIndex);
    return _res;
}

static PyObject *Qt_SpriteMediaSetActionVariable(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    QTAtomID variableID;
    float value;
#ifndef SpriteMediaSetActionVariable
    PyMac_PRECHECK(SpriteMediaSetActionVariable);
#endif
    if (!PyArg_ParseTuple(_args, "O&lf",
                          CmpInstObj_Convert, &mh,
                          &variableID,
                          &value))
        return NULL;
    _rv = SpriteMediaSetActionVariable(mh,
                                       variableID,
                                       &value);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SpriteMediaGetActionVariable(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    QTAtomID variableID;
    float value;
#ifndef SpriteMediaGetActionVariable
    PyMac_PRECHECK(SpriteMediaGetActionVariable);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &variableID))
        return NULL;
    _rv = SpriteMediaGetActionVariable(mh,
                                       variableID,
                                       &value);
    _res = Py_BuildValue("lf",
                         _rv,
                         value);
    return _res;
}

static PyObject *Qt_SpriteMediaDisposeSprite(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    QTAtomID spriteID;
#ifndef SpriteMediaDisposeSprite
    PyMac_PRECHECK(SpriteMediaDisposeSprite);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &spriteID))
        return NULL;
    _rv = SpriteMediaDisposeSprite(mh,
                                   spriteID);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SpriteMediaSetActionVariableToString(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    QTAtomID variableID;
    Ptr theCString;
#ifndef SpriteMediaSetActionVariableToString
    PyMac_PRECHECK(SpriteMediaSetActionVariableToString);
#endif
    if (!PyArg_ParseTuple(_args, "O&ls",
                          CmpInstObj_Convert, &mh,
                          &variableID,
                          &theCString))
        return NULL;
    _rv = SpriteMediaSetActionVariableToString(mh,
                                               variableID,
                                               theCString);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SpriteMediaGetActionVariableAsString(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    QTAtomID variableID;
    Handle theCString;
#ifndef SpriteMediaGetActionVariableAsString
    PyMac_PRECHECK(SpriteMediaGetActionVariableAsString);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &variableID))
        return NULL;
    _rv = SpriteMediaGetActionVariableAsString(mh,
                                               variableID,
                                               &theCString);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, theCString);
    return _res;
}

static PyObject *Qt_SpriteMediaNewImage(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Handle dataRef;
    OSType dataRefType;
    QTAtomID desiredID;
#ifndef SpriteMediaNewImage
    PyMac_PRECHECK(SpriteMediaNewImage);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&l",
                          CmpInstObj_Convert, &mh,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType,
                          &desiredID))
        return NULL;
    _rv = SpriteMediaNewImage(mh,
                              dataRef,
                              dataRefType,
                              desiredID);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SpriteMediaDisposeImage(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short imageIndex;
#ifndef SpriteMediaDisposeImage
    PyMac_PRECHECK(SpriteMediaDisposeImage);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &mh,
                          &imageIndex))
        return NULL;
    _rv = SpriteMediaDisposeImage(mh,
                                  imageIndex);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SpriteMediaImageIndexToID(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short imageIndex;
    QTAtomID imageID;
#ifndef SpriteMediaImageIndexToID
    PyMac_PRECHECK(SpriteMediaImageIndexToID);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &mh,
                          &imageIndex))
        return NULL;
    _rv = SpriteMediaImageIndexToID(mh,
                                    imageIndex,
                                    &imageID);
    _res = Py_BuildValue("ll",
                         _rv,
                         imageID);
    return _res;
}

static PyObject *Qt_SpriteMediaImageIDToIndex(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    QTAtomID imageID;
    short imageIndex;
#ifndef SpriteMediaImageIDToIndex
    PyMac_PRECHECK(SpriteMediaImageIDToIndex);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &imageID))
        return NULL;
    _rv = SpriteMediaImageIDToIndex(mh,
                                    imageID,
                                    &imageIndex);
    _res = Py_BuildValue("lh",
                         _rv,
                         imageIndex);
    return _res;
}

static PyObject *Qt_FlashMediaSetPan(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short xPercent;
    short yPercent;
#ifndef FlashMediaSetPan
    PyMac_PRECHECK(FlashMediaSetPan);
#endif
    if (!PyArg_ParseTuple(_args, "O&hh",
                          CmpInstObj_Convert, &mh,
                          &xPercent,
                          &yPercent))
        return NULL;
    _rv = FlashMediaSetPan(mh,
                           xPercent,
                           yPercent);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_FlashMediaSetZoom(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short factor;
#ifndef FlashMediaSetZoom
    PyMac_PRECHECK(FlashMediaSetZoom);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &mh,
                          &factor))
        return NULL;
    _rv = FlashMediaSetZoom(mh,
                            factor);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_FlashMediaSetZoomRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long left;
    long top;
    long right;
    long bottom;
#ifndef FlashMediaSetZoomRect
    PyMac_PRECHECK(FlashMediaSetZoomRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&llll",
                          CmpInstObj_Convert, &mh,
                          &left,
                          &top,
                          &right,
                          &bottom))
        return NULL;
    _rv = FlashMediaSetZoomRect(mh,
                                left,
                                top,
                                right,
                                bottom);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_FlashMediaGetRefConBounds(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long refCon;
    long left;
    long top;
    long right;
    long bottom;
#ifndef FlashMediaGetRefConBounds
    PyMac_PRECHECK(FlashMediaGetRefConBounds);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &refCon))
        return NULL;
    _rv = FlashMediaGetRefConBounds(mh,
                                    refCon,
                                    &left,
                                    &top,
                                    &right,
                                    &bottom);
    _res = Py_BuildValue("lllll",
                         _rv,
                         left,
                         top,
                         right,
                         bottom);
    return _res;
}

static PyObject *Qt_FlashMediaGetRefConID(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long refCon;
    long refConID;
#ifndef FlashMediaGetRefConID
    PyMac_PRECHECK(FlashMediaGetRefConID);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &refCon))
        return NULL;
    _rv = FlashMediaGetRefConID(mh,
                                refCon,
                                &refConID);
    _res = Py_BuildValue("ll",
                         _rv,
                         refConID);
    return _res;
}

static PyObject *Qt_FlashMediaIDToRefCon(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long refConID;
    long refCon;
#ifndef FlashMediaIDToRefCon
    PyMac_PRECHECK(FlashMediaIDToRefCon);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &refConID))
        return NULL;
    _rv = FlashMediaIDToRefCon(mh,
                               refConID,
                               &refCon);
    _res = Py_BuildValue("ll",
                         _rv,
                         refCon);
    return _res;
}

static PyObject *Qt_FlashMediaGetDisplayedFrameNumber(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long flashFrameNumber;
#ifndef FlashMediaGetDisplayedFrameNumber
    PyMac_PRECHECK(FlashMediaGetDisplayedFrameNumber);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = FlashMediaGetDisplayedFrameNumber(mh,
                                            &flashFrameNumber);
    _res = Py_BuildValue("ll",
                         _rv,
                         flashFrameNumber);
    return _res;
}

static PyObject *Qt_FlashMediaFrameNumberToMovieTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long flashFrameNumber;
    TimeValue movieTime;
#ifndef FlashMediaFrameNumberToMovieTime
    PyMac_PRECHECK(FlashMediaFrameNumberToMovieTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &flashFrameNumber))
        return NULL;
    _rv = FlashMediaFrameNumberToMovieTime(mh,
                                           flashFrameNumber,
                                           &movieTime);
    _res = Py_BuildValue("ll",
                         _rv,
                         movieTime);
    return _res;
}

static PyObject *Qt_FlashMediaFrameLabelToMovieTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Ptr theLabel;
    TimeValue movieTime;
#ifndef FlashMediaFrameLabelToMovieTime
    PyMac_PRECHECK(FlashMediaFrameLabelToMovieTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &mh,
                          &theLabel))
        return NULL;
    _rv = FlashMediaFrameLabelToMovieTime(mh,
                                          theLabel,
                                          &movieTime);
    _res = Py_BuildValue("ll",
                         _rv,
                         movieTime);
    return _res;
}

static PyObject *Qt_FlashMediaGetFlashVariable(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    char path;
    char name;
    Handle theVariableCStringOut;
#ifndef FlashMediaGetFlashVariable
    PyMac_PRECHECK(FlashMediaGetFlashVariable);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = FlashMediaGetFlashVariable(mh,
                                     &path,
                                     &name,
                                     &theVariableCStringOut);
    _res = Py_BuildValue("lccO&",
                         _rv,
                         path,
                         name,
                         ResObj_New, theVariableCStringOut);
    return _res;
}

static PyObject *Qt_FlashMediaSetFlashVariable(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    char path;
    char name;
    char value;
    Boolean updateFocus;
#ifndef FlashMediaSetFlashVariable
    PyMac_PRECHECK(FlashMediaSetFlashVariable);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          CmpInstObj_Convert, &mh,
                          &updateFocus))
        return NULL;
    _rv = FlashMediaSetFlashVariable(mh,
                                     &path,
                                     &name,
                                     &value,
                                     updateFocus);
    _res = Py_BuildValue("lccc",
                         _rv,
                         path,
                         name,
                         value);
    return _res;
}

static PyObject *Qt_FlashMediaDoButtonActions(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    char path;
    long buttonID;
    long transition;
#ifndef FlashMediaDoButtonActions
    PyMac_PRECHECK(FlashMediaDoButtonActions);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mh,
                          &buttonID,
                          &transition))
        return NULL;
    _rv = FlashMediaDoButtonActions(mh,
                                    &path,
                                    buttonID,
                                    transition);
    _res = Py_BuildValue("lc",
                         _rv,
                         path);
    return _res;
}

static PyObject *Qt_FlashMediaGetSupportedSwfVersion(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    UInt8 swfVersion;
#ifndef FlashMediaGetSupportedSwfVersion
    PyMac_PRECHECK(FlashMediaGetSupportedSwfVersion);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = FlashMediaGetSupportedSwfVersion(mh,
                                           &swfVersion);
    _res = Py_BuildValue("lb",
                         _rv,
                         swfVersion);
    return _res;
}

static PyObject *Qt_Media3DGetCurrentGroup(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    void * group;
#ifndef Media3DGetCurrentGroup
    PyMac_PRECHECK(Media3DGetCurrentGroup);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &mh,
                          &group))
        return NULL;
    _rv = Media3DGetCurrentGroup(mh,
                                 group);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_Media3DTranslateNamedObjectTo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    char objectName;
    Fixed x;
    Fixed y;
    Fixed z;
#ifndef Media3DTranslateNamedObjectTo
    PyMac_PRECHECK(Media3DTranslateNamedObjectTo);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&",
                          CmpInstObj_Convert, &mh,
                          PyMac_GetFixed, &x,
                          PyMac_GetFixed, &y,
                          PyMac_GetFixed, &z))
        return NULL;
    _rv = Media3DTranslateNamedObjectTo(mh,
                                        &objectName,
                                        x,
                                        y,
                                        z);
    _res = Py_BuildValue("lc",
                         _rv,
                         objectName);
    return _res;
}

static PyObject *Qt_Media3DScaleNamedObjectTo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    char objectName;
    Fixed xScale;
    Fixed yScale;
    Fixed zScale;
#ifndef Media3DScaleNamedObjectTo
    PyMac_PRECHECK(Media3DScaleNamedObjectTo);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&",
                          CmpInstObj_Convert, &mh,
                          PyMac_GetFixed, &xScale,
                          PyMac_GetFixed, &yScale,
                          PyMac_GetFixed, &zScale))
        return NULL;
    _rv = Media3DScaleNamedObjectTo(mh,
                                    &objectName,
                                    xScale,
                                    yScale,
                                    zScale);
    _res = Py_BuildValue("lc",
                         _rv,
                         objectName);
    return _res;
}

static PyObject *Qt_Media3DRotateNamedObjectTo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    char objectName;
    Fixed xDegrees;
    Fixed yDegrees;
    Fixed zDegrees;
#ifndef Media3DRotateNamedObjectTo
    PyMac_PRECHECK(Media3DRotateNamedObjectTo);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&",
                          CmpInstObj_Convert, &mh,
                          PyMac_GetFixed, &xDegrees,
                          PyMac_GetFixed, &yDegrees,
                          PyMac_GetFixed, &zDegrees))
        return NULL;
    _rv = Media3DRotateNamedObjectTo(mh,
                                     &objectName,
                                     xDegrees,
                                     yDegrees,
                                     zDegrees);
    _res = Py_BuildValue("lc",
                         _rv,
                         objectName);
    return _res;
}

static PyObject *Qt_Media3DSetCameraData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    void * cameraData;
#ifndef Media3DSetCameraData
    PyMac_PRECHECK(Media3DSetCameraData);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &mh,
                          &cameraData))
        return NULL;
    _rv = Media3DSetCameraData(mh,
                               cameraData);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_Media3DGetCameraData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    void * cameraData;
#ifndef Media3DGetCameraData
    PyMac_PRECHECK(Media3DGetCameraData);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &mh,
                          &cameraData))
        return NULL;
    _rv = Media3DGetCameraData(mh,
                               cameraData);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_Media3DSetCameraAngleAspect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    QTFloatSingle fov;
    QTFloatSingle aspectRatioXToY;
#ifndef Media3DSetCameraAngleAspect
    PyMac_PRECHECK(Media3DSetCameraAngleAspect);
#endif
    if (!PyArg_ParseTuple(_args, "O&ff",
                          CmpInstObj_Convert, &mh,
                          &fov,
                          &aspectRatioXToY))
        return NULL;
    _rv = Media3DSetCameraAngleAspect(mh,
                                      fov,
                                      aspectRatioXToY);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_Media3DGetCameraAngleAspect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    QTFloatSingle fov;
    QTFloatSingle aspectRatioXToY;
#ifndef Media3DGetCameraAngleAspect
    PyMac_PRECHECK(Media3DGetCameraAngleAspect);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = Media3DGetCameraAngleAspect(mh,
                                      &fov,
                                      &aspectRatioXToY);
    _res = Py_BuildValue("lff",
                         _rv,
                         fov,
                         aspectRatioXToY);
    return _res;
}

static PyObject *Qt_Media3DSetCameraRange(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    void * tQ3CameraRange;
#ifndef Media3DSetCameraRange
    PyMac_PRECHECK(Media3DSetCameraRange);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &mh,
                          &tQ3CameraRange))
        return NULL;
    _rv = Media3DSetCameraRange(mh,
                                tQ3CameraRange);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_Media3DGetCameraRange(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    void * tQ3CameraRange;
#ifndef Media3DGetCameraRange
    PyMac_PRECHECK(Media3DGetCameraRange);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &mh,
                          &tQ3CameraRange))
        return NULL;
    _rv = Media3DGetCameraRange(mh,
                                tQ3CameraRange);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_NewTimeBase(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeBase _rv;
#ifndef NewTimeBase
    PyMac_PRECHECK(NewTimeBase);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = NewTimeBase();
    _res = Py_BuildValue("O&",
                         TimeBaseObj_New, _rv);
    return _res;
}

static PyObject *Qt_ConvertTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeRecord theTime;
    TimeBase newBase;
#ifndef ConvertTime
    PyMac_PRECHECK(ConvertTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          QtTimeRecord_Convert, &theTime,
                          TimeBaseObj_Convert, &newBase))
        return NULL;
    ConvertTime(&theTime,
                newBase);
    _res = Py_BuildValue("O&",
                         QtTimeRecord_New, &theTime);
    return _res;
}

static PyObject *Qt_ConvertTimeScale(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeRecord theTime;
    TimeScale newScale;
#ifndef ConvertTimeScale
    PyMac_PRECHECK(ConvertTimeScale);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          QtTimeRecord_Convert, &theTime,
                          &newScale))
        return NULL;
    ConvertTimeScale(&theTime,
                     newScale);
    _res = Py_BuildValue("O&",
                         QtTimeRecord_New, &theTime);
    return _res;
}

static PyObject *Qt_AddTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeRecord dst;
    TimeRecord src;
#ifndef AddTime
    PyMac_PRECHECK(AddTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          QtTimeRecord_Convert, &dst,
                          QtTimeRecord_Convert, &src))
        return NULL;
    AddTime(&dst,
        &src);
    _res = Py_BuildValue("O&",
                         QtTimeRecord_New, &dst);
    return _res;
}

static PyObject *Qt_SubtractTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    TimeRecord dst;
    TimeRecord src;
#ifndef SubtractTime
    PyMac_PRECHECK(SubtractTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          QtTimeRecord_Convert, &dst,
                          QtTimeRecord_Convert, &src))
        return NULL;
    SubtractTime(&dst,
                 &src);
    _res = Py_BuildValue("O&",
                         QtTimeRecord_New, &dst);
    return _res;
}

static PyObject *Qt_MusicMediaGetIndexedTunePlayer(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ti;
    long sampleDescIndex;
    ComponentInstance tp;
#ifndef MusicMediaGetIndexedTunePlayer
    PyMac_PRECHECK(MusicMediaGetIndexedTunePlayer);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ti,
                          &sampleDescIndex))
        return NULL;
    _rv = MusicMediaGetIndexedTunePlayer(ti,
                                         sampleDescIndex,
                                         &tp);
    _res = Py_BuildValue("lO&",
                         _rv,
                         CmpInstObj_New, tp);
    return _res;
}

static PyObject *Qt_CodecManagerVersion(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    long version;
#ifndef CodecManagerVersion
    PyMac_PRECHECK(CodecManagerVersion);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = CodecManagerVersion(&version);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         version);
    return _res;
}

static PyObject *Qt_GetMaxCompressionSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    PixMapHandle src;
    Rect srcRect;
    short colorDepth;
    CodecQ quality;
    CodecType cType;
    CompressorComponent codec;
    long size;
#ifndef GetMaxCompressionSize
    PyMac_PRECHECK(GetMaxCompressionSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&hlO&O&",
                          ResObj_Convert, &src,
                          PyMac_GetRect, &srcRect,
                          &colorDepth,
                          &quality,
                          PyMac_GetOSType, &cType,
                          CmpObj_Convert, &codec))
        return NULL;
    _err = GetMaxCompressionSize(src,
                                 &srcRect,
                                 colorDepth,
                                 quality,
                                 cType,
                                 codec,
                                 &size);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         size);
    return _res;
}

static PyObject *Qt_GetCompressionTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    PixMapHandle src;
    Rect srcRect;
    short colorDepth;
    CodecType cType;
    CompressorComponent codec;
    CodecQ spatialQuality;
    CodecQ temporalQuality;
    unsigned long compressTime;
#ifndef GetCompressionTime
    PyMac_PRECHECK(GetCompressionTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&hO&O&",
                          ResObj_Convert, &src,
                          PyMac_GetRect, &srcRect,
                          &colorDepth,
                          PyMac_GetOSType, &cType,
                          CmpObj_Convert, &codec))
        return NULL;
    _err = GetCompressionTime(src,
                              &srcRect,
                              colorDepth,
                              cType,
                              codec,
                              &spatialQuality,
                              &temporalQuality,
                              &compressTime);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("lll",
                         spatialQuality,
                         temporalQuality,
                         compressTime);
    return _res;
}

static PyObject *Qt_CompressImage(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    PixMapHandle src;
    Rect srcRect;
    CodecQ quality;
    CodecType cType;
    ImageDescriptionHandle desc;
    Ptr data;
#ifndef CompressImage
    PyMac_PRECHECK(CompressImage);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&lO&O&s",
                          ResObj_Convert, &src,
                          PyMac_GetRect, &srcRect,
                          &quality,
                          PyMac_GetOSType, &cType,
                          ResObj_Convert, &desc,
                          &data))
        return NULL;
    _err = CompressImage(src,
                         &srcRect,
                         quality,
                         cType,
                         desc,
                         data);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_DecompressImage(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Ptr data;
    ImageDescriptionHandle desc;
    PixMapHandle dst;
    Rect srcRect;
    Rect dstRect;
    short mode;
    RgnHandle mask;
#ifndef DecompressImage
    PyMac_PRECHECK(DecompressImage);
#endif
    if (!PyArg_ParseTuple(_args, "sO&O&O&O&hO&",
                          &data,
                          ResObj_Convert, &desc,
                          ResObj_Convert, &dst,
                          PyMac_GetRect, &srcRect,
                          PyMac_GetRect, &dstRect,
                          &mode,
                          ResObj_Convert, &mask))
        return NULL;
    _err = DecompressImage(data,
                           desc,
                           dst,
                           &srcRect,
                           &dstRect,
                           mode,
                           mask);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_GetSimilarity(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    PixMapHandle src;
    Rect srcRect;
    ImageDescriptionHandle desc;
    Ptr data;
    Fixed similarity;
#ifndef GetSimilarity
    PyMac_PRECHECK(GetSimilarity);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&s",
                          ResObj_Convert, &src,
                          PyMac_GetRect, &srcRect,
                          ResObj_Convert, &desc,
                          &data))
        return NULL;
    _err = GetSimilarity(src,
                         &srcRect,
                         desc,
                         data,
                         &similarity);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, similarity);
    return _res;
}

static PyObject *Qt_GetImageDescriptionCTable(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    ImageDescriptionHandle desc;
    CTabHandle ctable;
#ifndef GetImageDescriptionCTable
    PyMac_PRECHECK(GetImageDescriptionCTable);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &desc))
        return NULL;
    _err = GetImageDescriptionCTable(desc,
                                     &ctable);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         ResObj_New, ctable);
    return _res;
}

static PyObject *Qt_SetImageDescriptionCTable(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    ImageDescriptionHandle desc;
    CTabHandle ctable;
#ifndef SetImageDescriptionCTable
    PyMac_PRECHECK(SetImageDescriptionCTable);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &desc,
                          ResObj_Convert, &ctable))
        return NULL;
    _err = SetImageDescriptionCTable(desc,
                                     ctable);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_GetImageDescriptionExtension(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    ImageDescriptionHandle desc;
    Handle extension;
    long idType;
    long index;
#ifndef GetImageDescriptionExtension
    PyMac_PRECHECK(GetImageDescriptionExtension);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          ResObj_Convert, &desc,
                          &idType,
                          &index))
        return NULL;
    _err = GetImageDescriptionExtension(desc,
                                        &extension,
                                        idType,
                                        index);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         ResObj_New, extension);
    return _res;
}

static PyObject *Qt_AddImageDescriptionExtension(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    ImageDescriptionHandle desc;
    Handle extension;
    long idType;
#ifndef AddImageDescriptionExtension
    PyMac_PRECHECK(AddImageDescriptionExtension);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          ResObj_Convert, &desc,
                          ResObj_Convert, &extension,
                          &idType))
        return NULL;
    _err = AddImageDescriptionExtension(desc,
                                        extension,
                                        idType);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_RemoveImageDescriptionExtension(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    ImageDescriptionHandle desc;
    long idType;
    long index;
#ifndef RemoveImageDescriptionExtension
    PyMac_PRECHECK(RemoveImageDescriptionExtension);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          ResObj_Convert, &desc,
                          &idType,
                          &index))
        return NULL;
    _err = RemoveImageDescriptionExtension(desc,
                                           idType,
                                           index);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_CountImageDescriptionExtensionType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    ImageDescriptionHandle desc;
    long idType;
    long count;
#ifndef CountImageDescriptionExtensionType
    PyMac_PRECHECK(CountImageDescriptionExtensionType);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          ResObj_Convert, &desc,
                          &idType))
        return NULL;
    _err = CountImageDescriptionExtensionType(desc,
                                              idType,
                                              &count);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         count);
    return _res;
}

static PyObject *Qt_GetNextImageDescriptionExtensionType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    ImageDescriptionHandle desc;
    long idType;
#ifndef GetNextImageDescriptionExtensionType
    PyMac_PRECHECK(GetNextImageDescriptionExtensionType);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &desc))
        return NULL;
    _err = GetNextImageDescriptionExtensionType(desc,
                                                &idType);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         idType);
    return _res;
}

static PyObject *Qt_FindCodec(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    CodecType cType;
    CodecComponent specCodec;
    CompressorComponent compressor;
    DecompressorComponent decompressor;
#ifndef FindCodec
    PyMac_PRECHECK(FindCodec);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          PyMac_GetOSType, &cType,
                          CmpObj_Convert, &specCodec))
        return NULL;
    _err = FindCodec(cType,
                     specCodec,
                     &compressor,
                     &decompressor);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&O&",
                         CmpObj_New, compressor,
                         CmpObj_New, decompressor);
    return _res;
}

static PyObject *Qt_CompressPicture(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    PicHandle srcPicture;
    PicHandle dstPicture;
    CodecQ quality;
    CodecType cType;
#ifndef CompressPicture
    PyMac_PRECHECK(CompressPicture);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&lO&",
                          ResObj_Convert, &srcPicture,
                          ResObj_Convert, &dstPicture,
                          &quality,
                          PyMac_GetOSType, &cType))
        return NULL;
    _err = CompressPicture(srcPicture,
                           dstPicture,
                           quality,
                           cType);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_CompressPictureFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    short srcRefNum;
    short dstRefNum;
    CodecQ quality;
    CodecType cType;
#ifndef CompressPictureFile
    PyMac_PRECHECK(CompressPictureFile);
#endif
    if (!PyArg_ParseTuple(_args, "hhlO&",
                          &srcRefNum,
                          &dstRefNum,
                          &quality,
                          PyMac_GetOSType, &cType))
        return NULL;
    _err = CompressPictureFile(srcRefNum,
                               dstRefNum,
                               quality,
                               cType);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_ConvertImage(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    ImageDescriptionHandle srcDD;
    Ptr srcData;
    short colorDepth;
    CTabHandle ctable;
    CodecQ accuracy;
    CodecQ quality;
    CodecType cType;
    CodecComponent codec;
    ImageDescriptionHandle dstDD;
    Ptr dstData;
#ifndef ConvertImage
    PyMac_PRECHECK(ConvertImage);
#endif
    if (!PyArg_ParseTuple(_args, "O&shO&llO&O&O&s",
                          ResObj_Convert, &srcDD,
                          &srcData,
                          &colorDepth,
                          ResObj_Convert, &ctable,
                          &accuracy,
                          &quality,
                          PyMac_GetOSType, &cType,
                          CmpObj_Convert, &codec,
                          ResObj_Convert, &dstDD,
                          &dstData))
        return NULL;
    _err = ConvertImage(srcDD,
                        srcData,
                        colorDepth,
                        ctable,
                        accuracy,
                        quality,
                        cType,
                        codec,
                        dstDD,
                        dstData);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_AddFilePreview(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    short resRefNum;
    OSType previewType;
    Handle previewData;
#ifndef AddFilePreview
    PyMac_PRECHECK(AddFilePreview);
#endif
    if (!PyArg_ParseTuple(_args, "hO&O&",
                          &resRefNum,
                          PyMac_GetOSType, &previewType,
                          ResObj_Convert, &previewData))
        return NULL;
    _err = AddFilePreview(resRefNum,
                          previewType,
                          previewData);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_GetBestDeviceRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    GDHandle gdh;
    Rect rp;
#ifndef GetBestDeviceRect
    PyMac_PRECHECK(GetBestDeviceRect);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetBestDeviceRect(&gdh,
                             &rp);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&O&",
                         OptResObj_New, gdh,
                         PyMac_BuildRect, &rp);
    return _res;
}

static PyObject *Qt_GDHasScale(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    GDHandle gdh;
    short depth;
    Fixed scale;
#ifndef GDHasScale
    PyMac_PRECHECK(GDHasScale);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          OptResObj_Convert, &gdh,
                          &depth))
        return NULL;
    _err = GDHasScale(gdh,
                      depth,
                      &scale);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, scale);
    return _res;
}

static PyObject *Qt_GDGetScale(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    GDHandle gdh;
    Fixed scale;
    short flags;
#ifndef GDGetScale
    PyMac_PRECHECK(GDGetScale);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          OptResObj_Convert, &gdh))
        return NULL;
    _err = GDGetScale(gdh,
                      &scale,
                      &flags);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&h",
                         PyMac_BuildFixed, scale,
                         flags);
    return _res;
}

static PyObject *Qt_GDSetScale(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    GDHandle gdh;
    Fixed scale;
    short flags;
#ifndef GDSetScale
    PyMac_PRECHECK(GDSetScale);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&h",
                          OptResObj_Convert, &gdh,
                          PyMac_GetFixed, &scale,
                          &flags))
        return NULL;
    _err = GDSetScale(gdh,
                      scale,
                      flags);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_GetGraphicsImporterForFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    FSSpec theFile;
    ComponentInstance gi;
#ifndef GetGraphicsImporterForFile
    PyMac_PRECHECK(GetGraphicsImporterForFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetFSSpec, &theFile))
        return NULL;
    _err = GetGraphicsImporterForFile(&theFile,
                                      &gi);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         CmpInstObj_New, gi);
    return _res;
}

static PyObject *Qt_GetGraphicsImporterForDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataRef;
    OSType dataRefType;
    ComponentInstance gi;
#ifndef GetGraphicsImporterForDataRef
    PyMac_PRECHECK(GetGraphicsImporterForDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _err = GetGraphicsImporterForDataRef(dataRef,
                                         dataRefType,
                                         &gi);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         CmpInstObj_New, gi);
    return _res;
}

static PyObject *Qt_GetGraphicsImporterForFileWithFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    FSSpec theFile;
    ComponentInstance gi;
    long flags;
#ifndef GetGraphicsImporterForFileWithFlags
    PyMac_PRECHECK(GetGraphicsImporterForFileWithFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          PyMac_GetFSSpec, &theFile,
                          &flags))
        return NULL;
    _err = GetGraphicsImporterForFileWithFlags(&theFile,
                                               &gi,
                                               flags);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         CmpInstObj_New, gi);
    return _res;
}

static PyObject *Qt_GetGraphicsImporterForDataRefWithFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataRef;
    OSType dataRefType;
    ComponentInstance gi;
    long flags;
#ifndef GetGraphicsImporterForDataRefWithFlags
    PyMac_PRECHECK(GetGraphicsImporterForDataRefWithFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType,
                          &flags))
        return NULL;
    _err = GetGraphicsImporterForDataRefWithFlags(dataRef,
                                                  dataRefType,
                                                  &gi,
                                                  flags);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         CmpInstObj_New, gi);
    return _res;
}

static PyObject *Qt_MakeImageDescriptionForPixMap(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    PixMapHandle pixmap;
    ImageDescriptionHandle idh;
#ifndef MakeImageDescriptionForPixMap
    PyMac_PRECHECK(MakeImageDescriptionForPixMap);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &pixmap))
        return NULL;
    _err = MakeImageDescriptionForPixMap(pixmap,
                                         &idh);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         ResObj_New, idh);
    return _res;
}

static PyObject *Qt_MakeImageDescriptionForEffect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    OSType effectType;
    ImageDescriptionHandle idh;
#ifndef MakeImageDescriptionForEffect
    PyMac_PRECHECK(MakeImageDescriptionForEffect);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetOSType, &effectType))
        return NULL;
    _err = MakeImageDescriptionForEffect(effectType,
                                         &idh);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         ResObj_New, idh);
    return _res;
}

static PyObject *Qt_QTGetPixelSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short _rv;
    OSType PixelFormat;
#ifndef QTGetPixelSize
    PyMac_PRECHECK(QTGetPixelSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetOSType, &PixelFormat))
        return NULL;
    _rv = QTGetPixelSize(PixelFormat);
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *Qt_QTGetPixelFormatDepthForImageDescription(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short _rv;
    OSType PixelFormat;
#ifndef QTGetPixelFormatDepthForImageDescription
    PyMac_PRECHECK(QTGetPixelFormatDepthForImageDescription);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetOSType, &PixelFormat))
        return NULL;
    _rv = QTGetPixelFormatDepthForImageDescription(PixelFormat);
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *Qt_QTGetPixMapHandleRowBytes(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
    PixMapHandle pm;
#ifndef QTGetPixMapHandleRowBytes
    PyMac_PRECHECK(QTGetPixMapHandleRowBytes);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &pm))
        return NULL;
    _rv = QTGetPixMapHandleRowBytes(pm);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_QTSetPixMapHandleRowBytes(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    PixMapHandle pm;
    long rowBytes;
#ifndef QTSetPixMapHandleRowBytes
    PyMac_PRECHECK(QTSetPixMapHandleRowBytes);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          ResObj_Convert, &pm,
                          &rowBytes))
        return NULL;
    _err = QTSetPixMapHandleRowBytes(pm,
                                     rowBytes);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_QTGetPixMapHandleGammaLevel(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed _rv;
    PixMapHandle pm;
#ifndef QTGetPixMapHandleGammaLevel
    PyMac_PRECHECK(QTGetPixMapHandleGammaLevel);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &pm))
        return NULL;
    _rv = QTGetPixMapHandleGammaLevel(pm);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *Qt_QTSetPixMapHandleGammaLevel(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    PixMapHandle pm;
    Fixed gammaLevel;
#ifndef QTSetPixMapHandleGammaLevel
    PyMac_PRECHECK(QTSetPixMapHandleGammaLevel);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &pm,
                          PyMac_GetFixed, &gammaLevel))
        return NULL;
    _err = QTSetPixMapHandleGammaLevel(pm,
                                       gammaLevel);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_QTGetPixMapHandleRequestedGammaLevel(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed _rv;
    PixMapHandle pm;
#ifndef QTGetPixMapHandleRequestedGammaLevel
    PyMac_PRECHECK(QTGetPixMapHandleRequestedGammaLevel);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &pm))
        return NULL;
    _rv = QTGetPixMapHandleRequestedGammaLevel(pm);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *Qt_QTSetPixMapHandleRequestedGammaLevel(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    PixMapHandle pm;
    Fixed requestedGammaLevel;
#ifndef QTSetPixMapHandleRequestedGammaLevel
    PyMac_PRECHECK(QTSetPixMapHandleRequestedGammaLevel);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &pm,
                          PyMac_GetFixed, &requestedGammaLevel))
        return NULL;
    _err = QTSetPixMapHandleRequestedGammaLevel(pm,
                                                requestedGammaLevel);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_CompAdd(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    wide src;
    wide dst;
#ifndef CompAdd
    PyMac_PRECHECK(CompAdd);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    CompAdd(&src,
        &dst);
    _res = Py_BuildValue("O&O&",
                         PyMac_Buildwide, src,
                         PyMac_Buildwide, dst);
    return _res;
}

static PyObject *Qt_CompSub(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    wide src;
    wide dst;
#ifndef CompSub
    PyMac_PRECHECK(CompSub);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    CompSub(&src,
        &dst);
    _res = Py_BuildValue("O&O&",
                         PyMac_Buildwide, src,
                         PyMac_Buildwide, dst);
    return _res;
}

static PyObject *Qt_CompNeg(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    wide dst;
#ifndef CompNeg
    PyMac_PRECHECK(CompNeg);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    CompNeg(&dst);
    _res = Py_BuildValue("O&",
                         PyMac_Buildwide, dst);
    return _res;
}

static PyObject *Qt_CompShift(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    wide src;
    short shift;
#ifndef CompShift
    PyMac_PRECHECK(CompShift);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &shift))
        return NULL;
    CompShift(&src,
              shift);
    _res = Py_BuildValue("O&",
                         PyMac_Buildwide, src);
    return _res;
}

static PyObject *Qt_CompMul(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long src1;
    long src2;
    wide dst;
#ifndef CompMul
    PyMac_PRECHECK(CompMul);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &src1,
                          &src2))
        return NULL;
    CompMul(src1,
        src2,
        &dst);
    _res = Py_BuildValue("O&",
                         PyMac_Buildwide, dst);
    return _res;
}

static PyObject *Qt_CompDiv(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
    wide numerator;
    long denominator;
    long remainder;
#ifndef CompDiv
    PyMac_PRECHECK(CompDiv);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &denominator))
        return NULL;
    _rv = CompDiv(&numerator,
                  denominator,
                  &remainder);
    _res = Py_BuildValue("lO&l",
                         _rv,
                         PyMac_Buildwide, numerator,
                         remainder);
    return _res;
}

static PyObject *Qt_CompFixMul(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    wide compSrc;
    Fixed fixSrc;
    wide compDst;
#ifndef CompFixMul
    PyMac_PRECHECK(CompFixMul);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetFixed, &fixSrc))
        return NULL;
    CompFixMul(&compSrc,
               fixSrc,
               &compDst);
    _res = Py_BuildValue("O&O&",
                         PyMac_Buildwide, compSrc,
                         PyMac_Buildwide, compDst);
    return _res;
}

static PyObject *Qt_CompMulDiv(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    wide co;
    long mul;
    long divisor;
#ifndef CompMulDiv
    PyMac_PRECHECK(CompMulDiv);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &mul,
                          &divisor))
        return NULL;
    CompMulDiv(&co,
               mul,
               divisor);
    _res = Py_BuildValue("O&",
                         PyMac_Buildwide, co);
    return _res;
}

static PyObject *Qt_CompMulDivTrunc(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    wide co;
    long mul;
    long divisor;
    long remainder;
#ifndef CompMulDivTrunc
    PyMac_PRECHECK(CompMulDivTrunc);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &mul,
                          &divisor))
        return NULL;
    CompMulDivTrunc(&co,
                    mul,
                    divisor,
                    &remainder);
    _res = Py_BuildValue("O&l",
                         PyMac_Buildwide, co,
                         remainder);
    return _res;
}

static PyObject *Qt_CompCompare(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
    wide a;
    wide minusb;
#ifndef CompCompare
    PyMac_PRECHECK(CompCompare);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          PyMac_Getwide, &a,
                          PyMac_Getwide, &minusb))
        return NULL;
    _rv = CompCompare(&a,
                      &minusb);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_CompSquareRoot(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    unsigned long _rv;
    wide src;
#ifndef CompSquareRoot
    PyMac_PRECHECK(CompSquareRoot);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_Getwide, &src))
        return NULL;
    _rv = CompSquareRoot(&src);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_FixMulDiv(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed _rv;
    Fixed src;
    Fixed mul;
    Fixed divisor;
#ifndef FixMulDiv
    PyMac_PRECHECK(FixMulDiv);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          PyMac_GetFixed, &src,
                          PyMac_GetFixed, &mul,
                          PyMac_GetFixed, &divisor))
        return NULL;
    _rv = FixMulDiv(src,
                    mul,
                    divisor);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *Qt_UnsignedFixMulDiv(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed _rv;
    Fixed src;
    Fixed mul;
    Fixed divisor;
#ifndef UnsignedFixMulDiv
    PyMac_PRECHECK(UnsignedFixMulDiv);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          PyMac_GetFixed, &src,
                          PyMac_GetFixed, &mul,
                          PyMac_GetFixed, &divisor))
        return NULL;
    _rv = UnsignedFixMulDiv(src,
                            mul,
                            divisor);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *Qt_FixExp2(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed _rv;
    Fixed src;
#ifndef FixExp2
    PyMac_PRECHECK(FixExp2);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetFixed, &src))
        return NULL;
    _rv = FixExp2(src);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *Qt_FixLog2(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed _rv;
    Fixed src;
#ifndef FixLog2
    PyMac_PRECHECK(FixLog2);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetFixed, &src))
        return NULL;
    _rv = FixLog2(src);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *Qt_FixPow(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed _rv;
    Fixed base;
    Fixed exp;
#ifndef FixPow
    PyMac_PRECHECK(FixPow);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          PyMac_GetFixed, &base,
                          PyMac_GetFixed, &exp))
        return NULL;
    _rv = FixPow(base,
                 exp);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportSetDataReference(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Handle dataRef;
    OSType dataReType;
#ifndef GraphicsImportSetDataReference
    PyMac_PRECHECK(GraphicsImportSetDataReference);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataReType))
        return NULL;
    _rv = GraphicsImportSetDataReference(ci,
                                         dataRef,
                                         dataReType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetDataReference(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Handle dataRef;
    OSType dataReType;
#ifndef GraphicsImportGetDataReference
    PyMac_PRECHECK(GraphicsImportGetDataReference);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetDataReference(ci,
                                         &dataRef,
                                         &dataReType);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, dataRef,
                         PyMac_BuildOSType, dataReType);
    return _res;
}

static PyObject *Qt_GraphicsImportSetDataFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    FSSpec theFile;
#ifndef GraphicsImportSetDataFile
    PyMac_PRECHECK(GraphicsImportSetDataFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFSSpec, &theFile))
        return NULL;
    _rv = GraphicsImportSetDataFile(ci,
                                    &theFile);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetDataFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    FSSpec theFile;
#ifndef GraphicsImportGetDataFile
    PyMac_PRECHECK(GraphicsImportGetDataFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFSSpec, &theFile))
        return NULL;
    _rv = GraphicsImportGetDataFile(ci,
                                    &theFile);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportSetDataHandle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Handle h;
#ifndef GraphicsImportSetDataHandle
    PyMac_PRECHECK(GraphicsImportSetDataHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &h))
        return NULL;
    _rv = GraphicsImportSetDataHandle(ci,
                                      h);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetDataHandle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Handle h;
#ifndef GraphicsImportGetDataHandle
    PyMac_PRECHECK(GraphicsImportGetDataHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetDataHandle(ci,
                                      &h);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, h);
    return _res;
}

static PyObject *Qt_GraphicsImportGetImageDescription(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    ImageDescriptionHandle desc;
#ifndef GraphicsImportGetImageDescription
    PyMac_PRECHECK(GraphicsImportGetImageDescription);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetImageDescription(ci,
                                            &desc);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, desc);
    return _res;
}

static PyObject *Qt_GraphicsImportGetDataOffsetAndSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    unsigned long offset;
    unsigned long size;
#ifndef GraphicsImportGetDataOffsetAndSize
    PyMac_PRECHECK(GraphicsImportGetDataOffsetAndSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetDataOffsetAndSize(ci,
                                             &offset,
                                             &size);
    _res = Py_BuildValue("lll",
                         _rv,
                         offset,
                         size);
    return _res;
}

static PyObject *Qt_GraphicsImportReadData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    void * dataPtr;
    unsigned long dataOffset;
    unsigned long dataSize;
#ifndef GraphicsImportReadData
    PyMac_PRECHECK(GraphicsImportReadData);
#endif
    if (!PyArg_ParseTuple(_args, "O&sll",
                          CmpInstObj_Convert, &ci,
                          &dataPtr,
                          &dataOffset,
                          &dataSize))
        return NULL;
    _rv = GraphicsImportReadData(ci,
                                 dataPtr,
                                 dataOffset,
                                 dataSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportSetClip(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    RgnHandle clipRgn;
#ifndef GraphicsImportSetClip
    PyMac_PRECHECK(GraphicsImportSetClip);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &clipRgn))
        return NULL;
    _rv = GraphicsImportSetClip(ci,
                                clipRgn);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetClip(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    RgnHandle clipRgn;
#ifndef GraphicsImportGetClip
    PyMac_PRECHECK(GraphicsImportGetClip);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetClip(ci,
                                &clipRgn);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, clipRgn);
    return _res;
}

static PyObject *Qt_GraphicsImportSetSourceRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Rect sourceRect;
#ifndef GraphicsImportSetSourceRect
    PyMac_PRECHECK(GraphicsImportSetSourceRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetRect, &sourceRect))
        return NULL;
    _rv = GraphicsImportSetSourceRect(ci,
                                      &sourceRect);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetSourceRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Rect sourceRect;
#ifndef GraphicsImportGetSourceRect
    PyMac_PRECHECK(GraphicsImportGetSourceRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetSourceRect(ci,
                                      &sourceRect);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &sourceRect);
    return _res;
}

static PyObject *Qt_GraphicsImportGetNaturalBounds(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Rect naturalBounds;
#ifndef GraphicsImportGetNaturalBounds
    PyMac_PRECHECK(GraphicsImportGetNaturalBounds);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetNaturalBounds(ci,
                                         &naturalBounds);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &naturalBounds);
    return _res;
}

static PyObject *Qt_GraphicsImportDraw(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
#ifndef GraphicsImportDraw
    PyMac_PRECHECK(GraphicsImportDraw);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportDraw(ci);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportSetGWorld(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    CGrafPtr port;
    GDHandle gd;
#ifndef GraphicsImportSetGWorld
    PyMac_PRECHECK(GraphicsImportSetGWorld);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          GrafObj_Convert, &port,
                          OptResObj_Convert, &gd))
        return NULL;
    _rv = GraphicsImportSetGWorld(ci,
                                  port,
                                  gd);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetGWorld(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    CGrafPtr port;
    GDHandle gd;
#ifndef GraphicsImportGetGWorld
    PyMac_PRECHECK(GraphicsImportGetGWorld);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetGWorld(ci,
                                  &port,
                                  &gd);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         GrafObj_New, port,
                         OptResObj_New, gd);
    return _res;
}

static PyObject *Qt_GraphicsImportSetBoundsRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Rect bounds;
#ifndef GraphicsImportSetBoundsRect
    PyMac_PRECHECK(GraphicsImportSetBoundsRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetRect, &bounds))
        return NULL;
    _rv = GraphicsImportSetBoundsRect(ci,
                                      &bounds);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetBoundsRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Rect bounds;
#ifndef GraphicsImportGetBoundsRect
    PyMac_PRECHECK(GraphicsImportGetBoundsRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetBoundsRect(ci,
                                      &bounds);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &bounds);
    return _res;
}

static PyObject *Qt_GraphicsImportSaveAsPicture(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    FSSpec fss;
    ScriptCode scriptTag;
#ifndef GraphicsImportSaveAsPicture
    PyMac_PRECHECK(GraphicsImportSaveAsPicture);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&h",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFSSpec, &fss,
                          &scriptTag))
        return NULL;
    _rv = GraphicsImportSaveAsPicture(ci,
                                      &fss,
                                      scriptTag);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportSetGraphicsMode(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    long graphicsMode;
    RGBColor opColor;
#ifndef GraphicsImportSetGraphicsMode
    PyMac_PRECHECK(GraphicsImportSetGraphicsMode);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          CmpInstObj_Convert, &ci,
                          &graphicsMode,
                          QdRGB_Convert, &opColor))
        return NULL;
    _rv = GraphicsImportSetGraphicsMode(ci,
                                        graphicsMode,
                                        &opColor);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetGraphicsMode(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    long graphicsMode;
    RGBColor opColor;
#ifndef GraphicsImportGetGraphicsMode
    PyMac_PRECHECK(GraphicsImportGetGraphicsMode);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetGraphicsMode(ci,
                                        &graphicsMode,
                                        &opColor);
    _res = Py_BuildValue("llO&",
                         _rv,
                         graphicsMode,
                         QdRGB_New, &opColor);
    return _res;
}

static PyObject *Qt_GraphicsImportSetQuality(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    CodecQ quality;
#ifndef GraphicsImportSetQuality
    PyMac_PRECHECK(GraphicsImportSetQuality);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &quality))
        return NULL;
    _rv = GraphicsImportSetQuality(ci,
                                   quality);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetQuality(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    CodecQ quality;
#ifndef GraphicsImportGetQuality
    PyMac_PRECHECK(GraphicsImportGetQuality);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetQuality(ci,
                                   &quality);
    _res = Py_BuildValue("ll",
                         _rv,
                         quality);
    return _res;
}

static PyObject *Qt_GraphicsImportSaveAsQuickTimeImageFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    FSSpec fss;
    ScriptCode scriptTag;
#ifndef GraphicsImportSaveAsQuickTimeImageFile
    PyMac_PRECHECK(GraphicsImportSaveAsQuickTimeImageFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&h",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFSSpec, &fss,
                          &scriptTag))
        return NULL;
    _rv = GraphicsImportSaveAsQuickTimeImageFile(ci,
                                                 &fss,
                                                 scriptTag);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportSetDataReferenceOffsetAndLimit(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    unsigned long offset;
    unsigned long limit;
#ifndef GraphicsImportSetDataReferenceOffsetAndLimit
    PyMac_PRECHECK(GraphicsImportSetDataReferenceOffsetAndLimit);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &ci,
                          &offset,
                          &limit))
        return NULL;
    _rv = GraphicsImportSetDataReferenceOffsetAndLimit(ci,
                                                       offset,
                                                       limit);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetDataReferenceOffsetAndLimit(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    unsigned long offset;
    unsigned long limit;
#ifndef GraphicsImportGetDataReferenceOffsetAndLimit
    PyMac_PRECHECK(GraphicsImportGetDataReferenceOffsetAndLimit);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetDataReferenceOffsetAndLimit(ci,
                                                       &offset,
                                                       &limit);
    _res = Py_BuildValue("lll",
                         _rv,
                         offset,
                         limit);
    return _res;
}

static PyObject *Qt_GraphicsImportGetAliasedDataReference(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Handle dataRef;
    OSType dataRefType;
#ifndef GraphicsImportGetAliasedDataReference
    PyMac_PRECHECK(GraphicsImportGetAliasedDataReference);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetAliasedDataReference(ci,
                                                &dataRef,
                                                &dataRefType);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, dataRef,
                         PyMac_BuildOSType, dataRefType);
    return _res;
}

static PyObject *Qt_GraphicsImportValidate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Boolean valid;
#ifndef GraphicsImportValidate
    PyMac_PRECHECK(GraphicsImportValidate);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportValidate(ci,
                                 &valid);
    _res = Py_BuildValue("lb",
                         _rv,
                         valid);
    return _res;
}

static PyObject *Qt_GraphicsImportGetMetaData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    void * userData;
#ifndef GraphicsImportGetMetaData
    PyMac_PRECHECK(GraphicsImportGetMetaData);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &ci,
                          &userData))
        return NULL;
    _rv = GraphicsImportGetMetaData(ci,
                                    userData);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetMIMETypeList(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    void * qtAtomContainerPtr;
#ifndef GraphicsImportGetMIMETypeList
    PyMac_PRECHECK(GraphicsImportGetMIMETypeList);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &ci,
                          &qtAtomContainerPtr))
        return NULL;
    _rv = GraphicsImportGetMIMETypeList(ci,
                                        qtAtomContainerPtr);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportDoesDrawAllPixels(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    short drawsAllPixels;
#ifndef GraphicsImportDoesDrawAllPixels
    PyMac_PRECHECK(GraphicsImportDoesDrawAllPixels);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportDoesDrawAllPixels(ci,
                                          &drawsAllPixels);
    _res = Py_BuildValue("lh",
                         _rv,
                         drawsAllPixels);
    return _res;
}

static PyObject *Qt_GraphicsImportGetAsPicture(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    PicHandle picture;
#ifndef GraphicsImportGetAsPicture
    PyMac_PRECHECK(GraphicsImportGetAsPicture);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetAsPicture(ci,
                                     &picture);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, picture);
    return _res;
}

static PyObject *Qt_GraphicsImportExportImageFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    OSType fileType;
    OSType fileCreator;
    FSSpec fss;
    ScriptCode scriptTag;
#ifndef GraphicsImportExportImageFile
    PyMac_PRECHECK(GraphicsImportExportImageFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&h",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetOSType, &fileType,
                          PyMac_GetOSType, &fileCreator,
                          PyMac_GetFSSpec, &fss,
                          &scriptTag))
        return NULL;
    _rv = GraphicsImportExportImageFile(ci,
                                        fileType,
                                        fileCreator,
                                        &fss,
                                        scriptTag);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetExportImageTypeList(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    void * qtAtomContainerPtr;
#ifndef GraphicsImportGetExportImageTypeList
    PyMac_PRECHECK(GraphicsImportGetExportImageTypeList);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &ci,
                          &qtAtomContainerPtr))
        return NULL;
    _rv = GraphicsImportGetExportImageTypeList(ci,
                                               qtAtomContainerPtr);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetExportSettingsAsAtomContainer(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    void * qtAtomContainerPtr;
#ifndef GraphicsImportGetExportSettingsAsAtomContainer
    PyMac_PRECHECK(GraphicsImportGetExportSettingsAsAtomContainer);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &ci,
                          &qtAtomContainerPtr))
        return NULL;
    _rv = GraphicsImportGetExportSettingsAsAtomContainer(ci,
                                                         qtAtomContainerPtr);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportSetExportSettingsFromAtomContainer(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    void * qtAtomContainer;
#ifndef GraphicsImportSetExportSettingsFromAtomContainer
    PyMac_PRECHECK(GraphicsImportSetExportSettingsFromAtomContainer);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &ci,
                          &qtAtomContainer))
        return NULL;
    _rv = GraphicsImportSetExportSettingsFromAtomContainer(ci,
                                                           qtAtomContainer);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetImageCount(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    unsigned long imageCount;
#ifndef GraphicsImportGetImageCount
    PyMac_PRECHECK(GraphicsImportGetImageCount);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetImageCount(ci,
                                      &imageCount);
    _res = Py_BuildValue("ll",
                         _rv,
                         imageCount);
    return _res;
}

static PyObject *Qt_GraphicsImportSetImageIndex(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    unsigned long imageIndex;
#ifndef GraphicsImportSetImageIndex
    PyMac_PRECHECK(GraphicsImportSetImageIndex);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &imageIndex))
        return NULL;
    _rv = GraphicsImportSetImageIndex(ci,
                                      imageIndex);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetImageIndex(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    unsigned long imageIndex;
#ifndef GraphicsImportGetImageIndex
    PyMac_PRECHECK(GraphicsImportGetImageIndex);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetImageIndex(ci,
                                      &imageIndex);
    _res = Py_BuildValue("ll",
                         _rv,
                         imageIndex);
    return _res;
}

static PyObject *Qt_GraphicsImportGetDataOffsetAndSize64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    wide offset;
    wide size;
#ifndef GraphicsImportGetDataOffsetAndSize64
    PyMac_PRECHECK(GraphicsImportGetDataOffsetAndSize64);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetDataOffsetAndSize64(ci,
                                               &offset,
                                               &size);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         PyMac_Buildwide, offset,
                         PyMac_Buildwide, size);
    return _res;
}

static PyObject *Qt_GraphicsImportReadData64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    void * dataPtr;
    wide dataOffset;
    unsigned long dataSize;
#ifndef GraphicsImportReadData64
    PyMac_PRECHECK(GraphicsImportReadData64);
#endif
    if (!PyArg_ParseTuple(_args, "O&sO&l",
                          CmpInstObj_Convert, &ci,
                          &dataPtr,
                          PyMac_Getwide, &dataOffset,
                          &dataSize))
        return NULL;
    _rv = GraphicsImportReadData64(ci,
                                   dataPtr,
                                   &dataOffset,
                                   dataSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportSetDataReferenceOffsetAndLimit64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    wide offset;
    wide limit;
#ifndef GraphicsImportSetDataReferenceOffsetAndLimit64
    PyMac_PRECHECK(GraphicsImportSetDataReferenceOffsetAndLimit64);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_Getwide, &offset,
                          PyMac_Getwide, &limit))
        return NULL;
    _rv = GraphicsImportSetDataReferenceOffsetAndLimit64(ci,
                                                         &offset,
                                                         &limit);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetDataReferenceOffsetAndLimit64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    wide offset;
    wide limit;
#ifndef GraphicsImportGetDataReferenceOffsetAndLimit64
    PyMac_PRECHECK(GraphicsImportGetDataReferenceOffsetAndLimit64);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetDataReferenceOffsetAndLimit64(ci,
                                                         &offset,
                                                         &limit);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         PyMac_Buildwide, offset,
                         PyMac_Buildwide, limit);
    return _res;
}

static PyObject *Qt_GraphicsImportGetDefaultClip(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    RgnHandle defaultRgn;
#ifndef GraphicsImportGetDefaultClip
    PyMac_PRECHECK(GraphicsImportGetDefaultClip);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetDefaultClip(ci,
                                       &defaultRgn);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, defaultRgn);
    return _res;
}

static PyObject *Qt_GraphicsImportGetDefaultGraphicsMode(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    long defaultGraphicsMode;
    RGBColor defaultOpColor;
#ifndef GraphicsImportGetDefaultGraphicsMode
    PyMac_PRECHECK(GraphicsImportGetDefaultGraphicsMode);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetDefaultGraphicsMode(ci,
                                               &defaultGraphicsMode,
                                               &defaultOpColor);
    _res = Py_BuildValue("llO&",
                         _rv,
                         defaultGraphicsMode,
                         QdRGB_New, &defaultOpColor);
    return _res;
}

static PyObject *Qt_GraphicsImportGetDefaultSourceRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Rect defaultSourceRect;
#ifndef GraphicsImportGetDefaultSourceRect
    PyMac_PRECHECK(GraphicsImportGetDefaultSourceRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetDefaultSourceRect(ci,
                                             &defaultSourceRect);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &defaultSourceRect);
    return _res;
}

static PyObject *Qt_GraphicsImportGetColorSyncProfile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Handle profile;
#ifndef GraphicsImportGetColorSyncProfile
    PyMac_PRECHECK(GraphicsImportGetColorSyncProfile);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetColorSyncProfile(ci,
                                            &profile);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, profile);
    return _res;
}

static PyObject *Qt_GraphicsImportSetDestRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Rect destRect;
#ifndef GraphicsImportSetDestRect
    PyMac_PRECHECK(GraphicsImportSetDestRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetRect, &destRect))
        return NULL;
    _rv = GraphicsImportSetDestRect(ci,
                                    &destRect);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetDestRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    Rect destRect;
#ifndef GraphicsImportGetDestRect
    PyMac_PRECHECK(GraphicsImportGetDestRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetDestRect(ci,
                                    &destRect);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &destRect);
    return _res;
}

static PyObject *Qt_GraphicsImportSetFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    long flags;
#ifndef GraphicsImportSetFlags
    PyMac_PRECHECK(GraphicsImportSetFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &flags))
        return NULL;
    _rv = GraphicsImportSetFlags(ci,
                                 flags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImportGetFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    long flags;
#ifndef GraphicsImportGetFlags
    PyMac_PRECHECK(GraphicsImportGetFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetFlags(ci,
                                 &flags);
    _res = Py_BuildValue("ll",
                         _rv,
                         flags);
    return _res;
}

static PyObject *Qt_GraphicsImportGetBaseDataOffsetAndSize64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
    wide offset;
    wide size;
#ifndef GraphicsImportGetBaseDataOffsetAndSize64
    PyMac_PRECHECK(GraphicsImportGetBaseDataOffsetAndSize64);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportGetBaseDataOffsetAndSize64(ci,
                                                   &offset,
                                                   &size);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         PyMac_Buildwide, offset,
                         PyMac_Buildwide, size);
    return _res;
}

static PyObject *Qt_GraphicsImportSetImageIndexToThumbnail(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsImportComponent ci;
#ifndef GraphicsImportSetImageIndexToThumbnail
    PyMac_PRECHECK(GraphicsImportSetImageIndexToThumbnail);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImportSetImageIndexToThumbnail(ci);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportDoExport(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    unsigned long actualSizeWritten;
#ifndef GraphicsExportDoExport
    PyMac_PRECHECK(GraphicsExportDoExport);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportDoExport(ci,
                                 &actualSizeWritten);
    _res = Py_BuildValue("ll",
                         _rv,
                         actualSizeWritten);
    return _res;
}

static PyObject *Qt_GraphicsExportCanTranscode(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Boolean canTranscode;
#ifndef GraphicsExportCanTranscode
    PyMac_PRECHECK(GraphicsExportCanTranscode);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportCanTranscode(ci,
                                     &canTranscode);
    _res = Py_BuildValue("lb",
                         _rv,
                         canTranscode);
    return _res;
}

static PyObject *Qt_GraphicsExportDoTranscode(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
#ifndef GraphicsExportDoTranscode
    PyMac_PRECHECK(GraphicsExportDoTranscode);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportDoTranscode(ci);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportCanUseCompressor(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Boolean canUseCompressor;
    void * codecSettingsAtomContainerPtr;
#ifndef GraphicsExportCanUseCompressor
    PyMac_PRECHECK(GraphicsExportCanUseCompressor);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &ci,
                          &codecSettingsAtomContainerPtr))
        return NULL;
    _rv = GraphicsExportCanUseCompressor(ci,
                                         &canUseCompressor,
                                         codecSettingsAtomContainerPtr);
    _res = Py_BuildValue("lb",
                         _rv,
                         canUseCompressor);
    return _res;
}

static PyObject *Qt_GraphicsExportDoUseCompressor(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    void * codecSettingsAtomContainer;
    ImageDescriptionHandle outDesc;
#ifndef GraphicsExportDoUseCompressor
    PyMac_PRECHECK(GraphicsExportDoUseCompressor);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &ci,
                          &codecSettingsAtomContainer))
        return NULL;
    _rv = GraphicsExportDoUseCompressor(ci,
                                        codecSettingsAtomContainer,
                                        &outDesc);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, outDesc);
    return _res;
}

static PyObject *Qt_GraphicsExportDoStandaloneExport(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
#ifndef GraphicsExportDoStandaloneExport
    PyMac_PRECHECK(GraphicsExportDoStandaloneExport);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportDoStandaloneExport(ci);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetDefaultFileTypeAndCreator(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    OSType fileType;
    OSType fileCreator;
#ifndef GraphicsExportGetDefaultFileTypeAndCreator
    PyMac_PRECHECK(GraphicsExportGetDefaultFileTypeAndCreator);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetDefaultFileTypeAndCreator(ci,
                                                     &fileType,
                                                     &fileCreator);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         PyMac_BuildOSType, fileType,
                         PyMac_BuildOSType, fileCreator);
    return _res;
}

static PyObject *Qt_GraphicsExportGetDefaultFileNameExtension(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    OSType fileNameExtension;
#ifndef GraphicsExportGetDefaultFileNameExtension
    PyMac_PRECHECK(GraphicsExportGetDefaultFileNameExtension);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetDefaultFileNameExtension(ci,
                                                    &fileNameExtension);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildOSType, fileNameExtension);
    return _res;
}

static PyObject *Qt_GraphicsExportGetMIMETypeList(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    void * qtAtomContainerPtr;
#ifndef GraphicsExportGetMIMETypeList
    PyMac_PRECHECK(GraphicsExportGetMIMETypeList);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &ci,
                          &qtAtomContainerPtr))
        return NULL;
    _rv = GraphicsExportGetMIMETypeList(ci,
                                        qtAtomContainerPtr);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportSetSettingsFromAtomContainer(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    void * qtAtomContainer;
#ifndef GraphicsExportSetSettingsFromAtomContainer
    PyMac_PRECHECK(GraphicsExportSetSettingsFromAtomContainer);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &ci,
                          &qtAtomContainer))
        return NULL;
    _rv = GraphicsExportSetSettingsFromAtomContainer(ci,
                                                     qtAtomContainer);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetSettingsAsAtomContainer(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    void * qtAtomContainerPtr;
#ifndef GraphicsExportGetSettingsAsAtomContainer
    PyMac_PRECHECK(GraphicsExportGetSettingsAsAtomContainer);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &ci,
                          &qtAtomContainerPtr))
        return NULL;
    _rv = GraphicsExportGetSettingsAsAtomContainer(ci,
                                                   qtAtomContainerPtr);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetSettingsAsText(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Handle theText;
#ifndef GraphicsExportGetSettingsAsText
    PyMac_PRECHECK(GraphicsExportGetSettingsAsText);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetSettingsAsText(ci,
                                          &theText);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, theText);
    return _res;
}

static PyObject *Qt_GraphicsExportSetDontRecompress(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Boolean dontRecompress;
#ifndef GraphicsExportSetDontRecompress
    PyMac_PRECHECK(GraphicsExportSetDontRecompress);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          CmpInstObj_Convert, &ci,
                          &dontRecompress))
        return NULL;
    _rv = GraphicsExportSetDontRecompress(ci,
                                          dontRecompress);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetDontRecompress(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Boolean dontRecompress;
#ifndef GraphicsExportGetDontRecompress
    PyMac_PRECHECK(GraphicsExportGetDontRecompress);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetDontRecompress(ci,
                                          &dontRecompress);
    _res = Py_BuildValue("lb",
                         _rv,
                         dontRecompress);
    return _res;
}

static PyObject *Qt_GraphicsExportSetInterlaceStyle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    unsigned long interlaceStyle;
#ifndef GraphicsExportSetInterlaceStyle
    PyMac_PRECHECK(GraphicsExportSetInterlaceStyle);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &interlaceStyle))
        return NULL;
    _rv = GraphicsExportSetInterlaceStyle(ci,
                                          interlaceStyle);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetInterlaceStyle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    unsigned long interlaceStyle;
#ifndef GraphicsExportGetInterlaceStyle
    PyMac_PRECHECK(GraphicsExportGetInterlaceStyle);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetInterlaceStyle(ci,
                                          &interlaceStyle);
    _res = Py_BuildValue("ll",
                         _rv,
                         interlaceStyle);
    return _res;
}

static PyObject *Qt_GraphicsExportSetMetaData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    void * userData;
#ifndef GraphicsExportSetMetaData
    PyMac_PRECHECK(GraphicsExportSetMetaData);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &ci,
                          &userData))
        return NULL;
    _rv = GraphicsExportSetMetaData(ci,
                                    userData);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetMetaData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    void * userData;
#ifndef GraphicsExportGetMetaData
    PyMac_PRECHECK(GraphicsExportGetMetaData);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &ci,
                          &userData))
        return NULL;
    _rv = GraphicsExportGetMetaData(ci,
                                    userData);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportSetTargetDataSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    unsigned long targetDataSize;
#ifndef GraphicsExportSetTargetDataSize
    PyMac_PRECHECK(GraphicsExportSetTargetDataSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &targetDataSize))
        return NULL;
    _rv = GraphicsExportSetTargetDataSize(ci,
                                          targetDataSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetTargetDataSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    unsigned long targetDataSize;
#ifndef GraphicsExportGetTargetDataSize
    PyMac_PRECHECK(GraphicsExportGetTargetDataSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetTargetDataSize(ci,
                                          &targetDataSize);
    _res = Py_BuildValue("ll",
                         _rv,
                         targetDataSize);
    return _res;
}

static PyObject *Qt_GraphicsExportSetCompressionMethod(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    long compressionMethod;
#ifndef GraphicsExportSetCompressionMethod
    PyMac_PRECHECK(GraphicsExportSetCompressionMethod);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &compressionMethod))
        return NULL;
    _rv = GraphicsExportSetCompressionMethod(ci,
                                             compressionMethod);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetCompressionMethod(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    long compressionMethod;
#ifndef GraphicsExportGetCompressionMethod
    PyMac_PRECHECK(GraphicsExportGetCompressionMethod);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetCompressionMethod(ci,
                                             &compressionMethod);
    _res = Py_BuildValue("ll",
                         _rv,
                         compressionMethod);
    return _res;
}

static PyObject *Qt_GraphicsExportSetCompressionQuality(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    CodecQ spatialQuality;
#ifndef GraphicsExportSetCompressionQuality
    PyMac_PRECHECK(GraphicsExportSetCompressionQuality);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &spatialQuality))
        return NULL;
    _rv = GraphicsExportSetCompressionQuality(ci,
                                              spatialQuality);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetCompressionQuality(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    CodecQ spatialQuality;
#ifndef GraphicsExportGetCompressionQuality
    PyMac_PRECHECK(GraphicsExportGetCompressionQuality);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetCompressionQuality(ci,
                                              &spatialQuality);
    _res = Py_BuildValue("ll",
                         _rv,
                         spatialQuality);
    return _res;
}

static PyObject *Qt_GraphicsExportSetResolution(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Fixed horizontalResolution;
    Fixed verticalResolution;
#ifndef GraphicsExportSetResolution
    PyMac_PRECHECK(GraphicsExportSetResolution);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFixed, &horizontalResolution,
                          PyMac_GetFixed, &verticalResolution))
        return NULL;
    _rv = GraphicsExportSetResolution(ci,
                                      horizontalResolution,
                                      verticalResolution);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetResolution(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Fixed horizontalResolution;
    Fixed verticalResolution;
#ifndef GraphicsExportGetResolution
    PyMac_PRECHECK(GraphicsExportGetResolution);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetResolution(ci,
                                      &horizontalResolution,
                                      &verticalResolution);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         PyMac_BuildFixed, horizontalResolution,
                         PyMac_BuildFixed, verticalResolution);
    return _res;
}

static PyObject *Qt_GraphicsExportSetDepth(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    long depth;
#ifndef GraphicsExportSetDepth
    PyMac_PRECHECK(GraphicsExportSetDepth);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &depth))
        return NULL;
    _rv = GraphicsExportSetDepth(ci,
                                 depth);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetDepth(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    long depth;
#ifndef GraphicsExportGetDepth
    PyMac_PRECHECK(GraphicsExportGetDepth);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetDepth(ci,
                                 &depth);
    _res = Py_BuildValue("ll",
                         _rv,
                         depth);
    return _res;
}

static PyObject *Qt_GraphicsExportSetColorSyncProfile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Handle colorSyncProfile;
#ifndef GraphicsExportSetColorSyncProfile
    PyMac_PRECHECK(GraphicsExportSetColorSyncProfile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &colorSyncProfile))
        return NULL;
    _rv = GraphicsExportSetColorSyncProfile(ci,
                                            colorSyncProfile);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetColorSyncProfile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Handle colorSyncProfile;
#ifndef GraphicsExportGetColorSyncProfile
    PyMac_PRECHECK(GraphicsExportGetColorSyncProfile);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetColorSyncProfile(ci,
                                            &colorSyncProfile);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, colorSyncProfile);
    return _res;
}

static PyObject *Qt_GraphicsExportSetInputDataReference(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Handle dataRef;
    OSType dataRefType;
    ImageDescriptionHandle desc;
#ifndef GraphicsExportSetInputDataReference
    PyMac_PRECHECK(GraphicsExportSetInputDataReference);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType,
                          ResObj_Convert, &desc))
        return NULL;
    _rv = GraphicsExportSetInputDataReference(ci,
                                              dataRef,
                                              dataRefType,
                                              desc);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetInputDataReference(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Handle dataRef;
    OSType dataRefType;
#ifndef GraphicsExportGetInputDataReference
    PyMac_PRECHECK(GraphicsExportGetInputDataReference);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetInputDataReference(ci,
                                              &dataRef,
                                              &dataRefType);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, dataRef,
                         PyMac_BuildOSType, dataRefType);
    return _res;
}

static PyObject *Qt_GraphicsExportSetInputFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    FSSpec theFile;
    ImageDescriptionHandle desc;
#ifndef GraphicsExportSetInputFile
    PyMac_PRECHECK(GraphicsExportSetInputFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFSSpec, &theFile,
                          ResObj_Convert, &desc))
        return NULL;
    _rv = GraphicsExportSetInputFile(ci,
                                     &theFile,
                                     desc);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetInputFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    FSSpec theFile;
#ifndef GraphicsExportGetInputFile
    PyMac_PRECHECK(GraphicsExportGetInputFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFSSpec, &theFile))
        return NULL;
    _rv = GraphicsExportGetInputFile(ci,
                                     &theFile);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportSetInputHandle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Handle h;
    ImageDescriptionHandle desc;
#ifndef GraphicsExportSetInputHandle
    PyMac_PRECHECK(GraphicsExportSetInputHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &h,
                          ResObj_Convert, &desc))
        return NULL;
    _rv = GraphicsExportSetInputHandle(ci,
                                       h,
                                       desc);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetInputHandle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Handle h;
#ifndef GraphicsExportGetInputHandle
    PyMac_PRECHECK(GraphicsExportGetInputHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetInputHandle(ci,
                                       &h);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, h);
    return _res;
}

static PyObject *Qt_GraphicsExportSetInputPtr(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Ptr p;
    unsigned long size;
    ImageDescriptionHandle desc;
#ifndef GraphicsExportSetInputPtr
    PyMac_PRECHECK(GraphicsExportSetInputPtr);
#endif
    if (!PyArg_ParseTuple(_args, "O&slO&",
                          CmpInstObj_Convert, &ci,
                          &p,
                          &size,
                          ResObj_Convert, &desc))
        return NULL;
    _rv = GraphicsExportSetInputPtr(ci,
                                    p,
                                    size,
                                    desc);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportSetInputGraphicsImporter(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    GraphicsImportComponent grip;
#ifndef GraphicsExportSetInputGraphicsImporter
    PyMac_PRECHECK(GraphicsExportSetInputGraphicsImporter);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          CmpInstObj_Convert, &grip))
        return NULL;
    _rv = GraphicsExportSetInputGraphicsImporter(ci,
                                                 grip);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetInputGraphicsImporter(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    GraphicsImportComponent grip;
#ifndef GraphicsExportGetInputGraphicsImporter
    PyMac_PRECHECK(GraphicsExportGetInputGraphicsImporter);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetInputGraphicsImporter(ci,
                                                 &grip);
    _res = Py_BuildValue("lO&",
                         _rv,
                         CmpInstObj_New, grip);
    return _res;
}

static PyObject *Qt_GraphicsExportSetInputPicture(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    PicHandle picture;
#ifndef GraphicsExportSetInputPicture
    PyMac_PRECHECK(GraphicsExportSetInputPicture);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &picture))
        return NULL;
    _rv = GraphicsExportSetInputPicture(ci,
                                        picture);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetInputPicture(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    PicHandle picture;
#ifndef GraphicsExportGetInputPicture
    PyMac_PRECHECK(GraphicsExportGetInputPicture);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetInputPicture(ci,
                                        &picture);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, picture);
    return _res;
}

static PyObject *Qt_GraphicsExportSetInputGWorld(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    GWorldPtr gworld;
#ifndef GraphicsExportSetInputGWorld
    PyMac_PRECHECK(GraphicsExportSetInputGWorld);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          GWorldObj_Convert, &gworld))
        return NULL;
    _rv = GraphicsExportSetInputGWorld(ci,
                                       gworld);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetInputGWorld(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    GWorldPtr gworld;
#ifndef GraphicsExportGetInputGWorld
    PyMac_PRECHECK(GraphicsExportGetInputGWorld);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetInputGWorld(ci,
                                       &gworld);
    _res = Py_BuildValue("lO&",
                         _rv,
                         GWorldObj_New, gworld);
    return _res;
}

static PyObject *Qt_GraphicsExportSetInputPixmap(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    PixMapHandle pixmap;
#ifndef GraphicsExportSetInputPixmap
    PyMac_PRECHECK(GraphicsExportSetInputPixmap);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &pixmap))
        return NULL;
    _rv = GraphicsExportSetInputPixmap(ci,
                                       pixmap);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetInputPixmap(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    PixMapHandle pixmap;
#ifndef GraphicsExportGetInputPixmap
    PyMac_PRECHECK(GraphicsExportGetInputPixmap);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetInputPixmap(ci,
                                       &pixmap);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, pixmap);
    return _res;
}

static PyObject *Qt_GraphicsExportSetInputOffsetAndLimit(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    unsigned long offset;
    unsigned long limit;
#ifndef GraphicsExportSetInputOffsetAndLimit
    PyMac_PRECHECK(GraphicsExportSetInputOffsetAndLimit);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &ci,
                          &offset,
                          &limit))
        return NULL;
    _rv = GraphicsExportSetInputOffsetAndLimit(ci,
                                               offset,
                                               limit);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetInputOffsetAndLimit(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    unsigned long offset;
    unsigned long limit;
#ifndef GraphicsExportGetInputOffsetAndLimit
    PyMac_PRECHECK(GraphicsExportGetInputOffsetAndLimit);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetInputOffsetAndLimit(ci,
                                               &offset,
                                               &limit);
    _res = Py_BuildValue("lll",
                         _rv,
                         offset,
                         limit);
    return _res;
}

static PyObject *Qt_GraphicsExportMayExporterReadInputData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Boolean mayReadInputData;
#ifndef GraphicsExportMayExporterReadInputData
    PyMac_PRECHECK(GraphicsExportMayExporterReadInputData);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportMayExporterReadInputData(ci,
                                                 &mayReadInputData);
    _res = Py_BuildValue("lb",
                         _rv,
                         mayReadInputData);
    return _res;
}

static PyObject *Qt_GraphicsExportGetInputDataSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    unsigned long size;
#ifndef GraphicsExportGetInputDataSize
    PyMac_PRECHECK(GraphicsExportGetInputDataSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetInputDataSize(ci,
                                         &size);
    _res = Py_BuildValue("ll",
                         _rv,
                         size);
    return _res;
}

static PyObject *Qt_GraphicsExportReadInputData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    void * dataPtr;
    unsigned long dataOffset;
    unsigned long dataSize;
#ifndef GraphicsExportReadInputData
    PyMac_PRECHECK(GraphicsExportReadInputData);
#endif
    if (!PyArg_ParseTuple(_args, "O&sll",
                          CmpInstObj_Convert, &ci,
                          &dataPtr,
                          &dataOffset,
                          &dataSize))
        return NULL;
    _rv = GraphicsExportReadInputData(ci,
                                      dataPtr,
                                      dataOffset,
                                      dataSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetInputImageDescription(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    ImageDescriptionHandle desc;
#ifndef GraphicsExportGetInputImageDescription
    PyMac_PRECHECK(GraphicsExportGetInputImageDescription);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetInputImageDescription(ci,
                                                 &desc);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, desc);
    return _res;
}

static PyObject *Qt_GraphicsExportGetInputImageDimensions(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Rect dimensions;
#ifndef GraphicsExportGetInputImageDimensions
    PyMac_PRECHECK(GraphicsExportGetInputImageDimensions);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetInputImageDimensions(ci,
                                                &dimensions);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &dimensions);
    return _res;
}

static PyObject *Qt_GraphicsExportGetInputImageDepth(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    long inputDepth;
#ifndef GraphicsExportGetInputImageDepth
    PyMac_PRECHECK(GraphicsExportGetInputImageDepth);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetInputImageDepth(ci,
                                           &inputDepth);
    _res = Py_BuildValue("ll",
                         _rv,
                         inputDepth);
    return _res;
}

static PyObject *Qt_GraphicsExportDrawInputImage(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    CGrafPtr gw;
    GDHandle gd;
    Rect srcRect;
    Rect dstRect;
#ifndef GraphicsExportDrawInputImage
    PyMac_PRECHECK(GraphicsExportDrawInputImage);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&O&",
                          CmpInstObj_Convert, &ci,
                          GrafObj_Convert, &gw,
                          OptResObj_Convert, &gd,
                          PyMac_GetRect, &srcRect,
                          PyMac_GetRect, &dstRect))
        return NULL;
    _rv = GraphicsExportDrawInputImage(ci,
                                       gw,
                                       gd,
                                       &srcRect,
                                       &dstRect);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportSetOutputDataReference(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Handle dataRef;
    OSType dataRefType;
#ifndef GraphicsExportSetOutputDataReference
    PyMac_PRECHECK(GraphicsExportSetOutputDataReference);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _rv = GraphicsExportSetOutputDataReference(ci,
                                               dataRef,
                                               dataRefType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetOutputDataReference(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Handle dataRef;
    OSType dataRefType;
#ifndef GraphicsExportGetOutputDataReference
    PyMac_PRECHECK(GraphicsExportGetOutputDataReference);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetOutputDataReference(ci,
                                               &dataRef,
                                               &dataRefType);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, dataRef,
                         PyMac_BuildOSType, dataRefType);
    return _res;
}

static PyObject *Qt_GraphicsExportSetOutputFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    FSSpec theFile;
#ifndef GraphicsExportSetOutputFile
    PyMac_PRECHECK(GraphicsExportSetOutputFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFSSpec, &theFile))
        return NULL;
    _rv = GraphicsExportSetOutputFile(ci,
                                      &theFile);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetOutputFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    FSSpec theFile;
#ifndef GraphicsExportGetOutputFile
    PyMac_PRECHECK(GraphicsExportGetOutputFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFSSpec, &theFile))
        return NULL;
    _rv = GraphicsExportGetOutputFile(ci,
                                      &theFile);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportSetOutputHandle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Handle h;
#ifndef GraphicsExportSetOutputHandle
    PyMac_PRECHECK(GraphicsExportSetOutputHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &h))
        return NULL;
    _rv = GraphicsExportSetOutputHandle(ci,
                                        h);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetOutputHandle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Handle h;
#ifndef GraphicsExportGetOutputHandle
    PyMac_PRECHECK(GraphicsExportGetOutputHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetOutputHandle(ci,
                                        &h);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, h);
    return _res;
}

static PyObject *Qt_GraphicsExportSetOutputOffsetAndMaxSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    unsigned long offset;
    unsigned long maxSize;
    Boolean truncateFile;
#ifndef GraphicsExportSetOutputOffsetAndMaxSize
    PyMac_PRECHECK(GraphicsExportSetOutputOffsetAndMaxSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&llb",
                          CmpInstObj_Convert, &ci,
                          &offset,
                          &maxSize,
                          &truncateFile))
        return NULL;
    _rv = GraphicsExportSetOutputOffsetAndMaxSize(ci,
                                                  offset,
                                                  maxSize,
                                                  truncateFile);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetOutputOffsetAndMaxSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    unsigned long offset;
    unsigned long maxSize;
    Boolean truncateFile;
#ifndef GraphicsExportGetOutputOffsetAndMaxSize
    PyMac_PRECHECK(GraphicsExportGetOutputOffsetAndMaxSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetOutputOffsetAndMaxSize(ci,
                                                  &offset,
                                                  &maxSize,
                                                  &truncateFile);
    _res = Py_BuildValue("lllb",
                         _rv,
                         offset,
                         maxSize,
                         truncateFile);
    return _res;
}

static PyObject *Qt_GraphicsExportSetOutputFileTypeAndCreator(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    OSType fileType;
    OSType fileCreator;
#ifndef GraphicsExportSetOutputFileTypeAndCreator
    PyMac_PRECHECK(GraphicsExportSetOutputFileTypeAndCreator);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetOSType, &fileType,
                          PyMac_GetOSType, &fileCreator))
        return NULL;
    _rv = GraphicsExportSetOutputFileTypeAndCreator(ci,
                                                    fileType,
                                                    fileCreator);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetOutputFileTypeAndCreator(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    OSType fileType;
    OSType fileCreator;
#ifndef GraphicsExportGetOutputFileTypeAndCreator
    PyMac_PRECHECK(GraphicsExportGetOutputFileTypeAndCreator);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetOutputFileTypeAndCreator(ci,
                                                    &fileType,
                                                    &fileCreator);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         PyMac_BuildOSType, fileType,
                         PyMac_BuildOSType, fileCreator);
    return _res;
}

static PyObject *Qt_GraphicsExportSetOutputMark(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    unsigned long mark;
#ifndef GraphicsExportSetOutputMark
    PyMac_PRECHECK(GraphicsExportSetOutputMark);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &mark))
        return NULL;
    _rv = GraphicsExportSetOutputMark(ci,
                                      mark);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetOutputMark(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    unsigned long mark;
#ifndef GraphicsExportGetOutputMark
    PyMac_PRECHECK(GraphicsExportGetOutputMark);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetOutputMark(ci,
                                      &mark);
    _res = Py_BuildValue("ll",
                         _rv,
                         mark);
    return _res;
}

static PyObject *Qt_GraphicsExportReadOutputData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    void * dataPtr;
    unsigned long dataOffset;
    unsigned long dataSize;
#ifndef GraphicsExportReadOutputData
    PyMac_PRECHECK(GraphicsExportReadOutputData);
#endif
    if (!PyArg_ParseTuple(_args, "O&sll",
                          CmpInstObj_Convert, &ci,
                          &dataPtr,
                          &dataOffset,
                          &dataSize))
        return NULL;
    _rv = GraphicsExportReadOutputData(ci,
                                       dataPtr,
                                       dataOffset,
                                       dataSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportSetThumbnailEnabled(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Boolean enableThumbnail;
    long maxThumbnailWidth;
    long maxThumbnailHeight;
#ifndef GraphicsExportSetThumbnailEnabled
    PyMac_PRECHECK(GraphicsExportSetThumbnailEnabled);
#endif
    if (!PyArg_ParseTuple(_args, "O&bll",
                          CmpInstObj_Convert, &ci,
                          &enableThumbnail,
                          &maxThumbnailWidth,
                          &maxThumbnailHeight))
        return NULL;
    _rv = GraphicsExportSetThumbnailEnabled(ci,
                                            enableThumbnail,
                                            maxThumbnailWidth,
                                            maxThumbnailHeight);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetThumbnailEnabled(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Boolean thumbnailEnabled;
    long maxThumbnailWidth;
    long maxThumbnailHeight;
#ifndef GraphicsExportGetThumbnailEnabled
    PyMac_PRECHECK(GraphicsExportGetThumbnailEnabled);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetThumbnailEnabled(ci,
                                            &thumbnailEnabled,
                                            &maxThumbnailWidth,
                                            &maxThumbnailHeight);
    _res = Py_BuildValue("lbll",
                         _rv,
                         thumbnailEnabled,
                         maxThumbnailWidth,
                         maxThumbnailHeight);
    return _res;
}

static PyObject *Qt_GraphicsExportSetExifEnabled(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Boolean enableExif;
#ifndef GraphicsExportSetExifEnabled
    PyMac_PRECHECK(GraphicsExportSetExifEnabled);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          CmpInstObj_Convert, &ci,
                          &enableExif))
        return NULL;
    _rv = GraphicsExportSetExifEnabled(ci,
                                       enableExif);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsExportGetExifEnabled(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicsExportComponent ci;
    Boolean exifEnabled;
#ifndef GraphicsExportGetExifEnabled
    PyMac_PRECHECK(GraphicsExportGetExifEnabled);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsExportGetExifEnabled(ci,
                                       &exifEnabled);
    _res = Py_BuildValue("lb",
                         _rv,
                         exifEnabled);
    return _res;
}

static PyObject *Qt_ImageTranscoderBeginSequence(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ImageTranscoderComponent itc;
    ImageDescriptionHandle srcDesc;
    ImageDescriptionHandle dstDesc;
    void * data;
    long dataSize;
#ifndef ImageTranscoderBeginSequence
    PyMac_PRECHECK(ImageTranscoderBeginSequence);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&sl",
                          CmpInstObj_Convert, &itc,
                          ResObj_Convert, &srcDesc,
                          &data,
                          &dataSize))
        return NULL;
    _rv = ImageTranscoderBeginSequence(itc,
                                       srcDesc,
                                       &dstDesc,
                                       data,
                                       dataSize);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, dstDesc);
    return _res;
}

static PyObject *Qt_ImageTranscoderDisposeData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ImageTranscoderComponent itc;
    void * dstData;
#ifndef ImageTranscoderDisposeData
    PyMac_PRECHECK(ImageTranscoderDisposeData);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &itc,
                          &dstData))
        return NULL;
    _rv = ImageTranscoderDisposeData(itc,
                                     dstData);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_ImageTranscoderEndSequence(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ImageTranscoderComponent itc;
#ifndef ImageTranscoderEndSequence
    PyMac_PRECHECK(ImageTranscoderEndSequence);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &itc))
        return NULL;
    _rv = ImageTranscoderEndSequence(itc);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_ClockGetTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance aClock;
    TimeRecord out;
#ifndef ClockGetTime
    PyMac_PRECHECK(ClockGetTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &aClock))
        return NULL;
    _rv = ClockGetTime(aClock,
                       &out);
    _res = Py_BuildValue("lO&",
                         _rv,
                         QtTimeRecord_New, &out);
    return _res;
}

static PyObject *Qt_ClockSetTimeBase(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance aClock;
    TimeBase tb;
#ifndef ClockSetTimeBase
    PyMac_PRECHECK(ClockSetTimeBase);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &aClock,
                          TimeBaseObj_Convert, &tb))
        return NULL;
    _rv = ClockSetTimeBase(aClock,
                           tb);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_ClockGetRate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance aClock;
    Fixed rate;
#ifndef ClockGetRate
    PyMac_PRECHECK(ClockGetRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &aClock))
        return NULL;
    _rv = ClockGetRate(aClock,
                       &rate);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildFixed, rate);
    return _res;
}

static PyObject *Qt_SCPositionRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    Rect rp;
    Point where;
#ifndef SCPositionRect
    PyMac_PRECHECK(SCPositionRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = SCPositionRect(ci,
                         &rp,
                         &where);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         PyMac_BuildRect, &rp,
                         PyMac_BuildPoint, where);
    return _res;
}

static PyObject *Qt_SCPositionDialog(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    short id;
    Point where;
#ifndef SCPositionDialog
    PyMac_PRECHECK(SCPositionDialog);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &ci,
                          &id))
        return NULL;
    _rv = SCPositionDialog(ci,
                           id,
                           &where);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildPoint, where);
    return _res;
}

static PyObject *Qt_SCSetTestImagePictHandle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    PicHandle testPict;
    Rect testRect;
    short testFlags;
#ifndef SCSetTestImagePictHandle
    PyMac_PRECHECK(SCSetTestImagePictHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&h",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &testPict,
                          &testFlags))
        return NULL;
    _rv = SCSetTestImagePictHandle(ci,
                                   testPict,
                                   &testRect,
                                   testFlags);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &testRect);
    return _res;
}

static PyObject *Qt_SCSetTestImagePictFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    short testFileRef;
    Rect testRect;
    short testFlags;
#ifndef SCSetTestImagePictFile
    PyMac_PRECHECK(SCSetTestImagePictFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&hh",
                          CmpInstObj_Convert, &ci,
                          &testFileRef,
                          &testFlags))
        return NULL;
    _rv = SCSetTestImagePictFile(ci,
                                 testFileRef,
                                 &testRect,
                                 testFlags);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &testRect);
    return _res;
}

static PyObject *Qt_SCSetTestImagePixMap(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    PixMapHandle testPixMap;
    Rect testRect;
    short testFlags;
#ifndef SCSetTestImagePixMap
    PyMac_PRECHECK(SCSetTestImagePixMap);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&h",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &testPixMap,
                          &testFlags))
        return NULL;
    _rv = SCSetTestImagePixMap(ci,
                               testPixMap,
                               &testRect,
                               testFlags);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &testRect);
    return _res;
}

static PyObject *Qt_SCGetBestDeviceRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    Rect r;
#ifndef SCGetBestDeviceRect
    PyMac_PRECHECK(SCGetBestDeviceRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = SCGetBestDeviceRect(ci,
                              &r);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &r);
    return _res;
}

static PyObject *Qt_SCRequestImageSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
#ifndef SCRequestImageSettings
    PyMac_PRECHECK(SCRequestImageSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = SCRequestImageSettings(ci);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SCCompressImage(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    PixMapHandle src;
    Rect srcRect;
    ImageDescriptionHandle desc;
    Handle data;
#ifndef SCCompressImage
    PyMac_PRECHECK(SCCompressImage);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &src,
                          PyMac_GetRect, &srcRect))
        return NULL;
    _rv = SCCompressImage(ci,
                          src,
                          &srcRect,
                          &desc,
                          &data);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, desc,
                         ResObj_New, data);
    return _res;
}

static PyObject *Qt_SCCompressPicture(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    PicHandle srcPicture;
    PicHandle dstPicture;
#ifndef SCCompressPicture
    PyMac_PRECHECK(SCCompressPicture);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &srcPicture,
                          ResObj_Convert, &dstPicture))
        return NULL;
    _rv = SCCompressPicture(ci,
                            srcPicture,
                            dstPicture);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SCCompressPictureFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    short srcRefNum;
    short dstRefNum;
#ifndef SCCompressPictureFile
    PyMac_PRECHECK(SCCompressPictureFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&hh",
                          CmpInstObj_Convert, &ci,
                          &srcRefNum,
                          &dstRefNum))
        return NULL;
    _rv = SCCompressPictureFile(ci,
                                srcRefNum,
                                dstRefNum);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SCRequestSequenceSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
#ifndef SCRequestSequenceSettings
    PyMac_PRECHECK(SCRequestSequenceSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = SCRequestSequenceSettings(ci);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SCCompressSequenceBegin(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    PixMapHandle src;
    Rect srcRect;
    ImageDescriptionHandle desc;
#ifndef SCCompressSequenceBegin
    PyMac_PRECHECK(SCCompressSequenceBegin);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &src,
                          PyMac_GetRect, &srcRect))
        return NULL;
    _rv = SCCompressSequenceBegin(ci,
                                  src,
                                  &srcRect,
                                  &desc);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, desc);
    return _res;
}

static PyObject *Qt_SCCompressSequenceFrame(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    PixMapHandle src;
    Rect srcRect;
    Handle data;
    long dataSize;
    short notSyncFlag;
#ifndef SCCompressSequenceFrame
    PyMac_PRECHECK(SCCompressSequenceFrame);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &src,
                          PyMac_GetRect, &srcRect))
        return NULL;
    _rv = SCCompressSequenceFrame(ci,
                                  src,
                                  &srcRect,
                                  &data,
                                  &dataSize,
                                  &notSyncFlag);
    _res = Py_BuildValue("lO&lh",
                         _rv,
                         ResObj_New, data,
                         dataSize,
                         notSyncFlag);
    return _res;
}

static PyObject *Qt_SCCompressSequenceEnd(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
#ifndef SCCompressSequenceEnd
    PyMac_PRECHECK(SCCompressSequenceEnd);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = SCCompressSequenceEnd(ci);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SCDefaultPictHandleSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    PicHandle srcPicture;
    short motion;
#ifndef SCDefaultPictHandleSettings
    PyMac_PRECHECK(SCDefaultPictHandleSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&h",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &srcPicture,
                          &motion))
        return NULL;
    _rv = SCDefaultPictHandleSettings(ci,
                                      srcPicture,
                                      motion);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SCDefaultPictFileSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    short srcRef;
    short motion;
#ifndef SCDefaultPictFileSettings
    PyMac_PRECHECK(SCDefaultPictFileSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&hh",
                          CmpInstObj_Convert, &ci,
                          &srcRef,
                          &motion))
        return NULL;
    _rv = SCDefaultPictFileSettings(ci,
                                    srcRef,
                                    motion);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SCDefaultPixMapSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    PixMapHandle src;
    short motion;
#ifndef SCDefaultPixMapSettings
    PyMac_PRECHECK(SCDefaultPixMapSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&h",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &src,
                          &motion))
        return NULL;
    _rv = SCDefaultPixMapSettings(ci,
                                  src,
                                  motion);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SCGetInfo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    OSType infoType;
    void * info;
#ifndef SCGetInfo
    PyMac_PRECHECK(SCGetInfo);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&s",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetOSType, &infoType,
                          &info))
        return NULL;
    _rv = SCGetInfo(ci,
                    infoType,
                    info);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SCSetInfo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    OSType infoType;
    void * info;
#ifndef SCSetInfo
    PyMac_PRECHECK(SCSetInfo);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&s",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetOSType, &infoType,
                          &info))
        return NULL;
    _rv = SCSetInfo(ci,
                    infoType,
                    info);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SCSetCompressFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    long flags;
#ifndef SCSetCompressFlags
    PyMac_PRECHECK(SCSetCompressFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &flags))
        return NULL;
    _rv = SCSetCompressFlags(ci,
                             flags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SCGetCompressFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    long flags;
#ifndef SCGetCompressFlags
    PyMac_PRECHECK(SCGetCompressFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = SCGetCompressFlags(ci,
                             &flags);
    _res = Py_BuildValue("ll",
                         _rv,
                         flags);
    return _res;
}

static PyObject *Qt_SCGetSettingsAsText(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
    Handle text;
#ifndef SCGetSettingsAsText
    PyMac_PRECHECK(SCGetSettingsAsText);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = SCGetSettingsAsText(ci,
                              &text);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, text);
    return _res;
}

static PyObject *Qt_SCAsyncIdle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance ci;
#ifndef SCAsyncIdle
    PyMac_PRECHECK(SCAsyncIdle);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = SCAsyncIdle(ci);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TweenerReset(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TweenerComponent tc;
#ifndef TweenerReset
    PyMac_PRECHECK(TweenerReset);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &tc))
        return NULL;
    _rv = TweenerReset(tc);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TCGetSourceRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    HandlerError _rv;
    MediaHandler mh;
    TimeCodeDescriptionHandle tcdH;
    UserData srefH;
#ifndef TCGetSourceRef
    PyMac_PRECHECK(TCGetSourceRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          ResObj_Convert, &tcdH))
        return NULL;
    _rv = TCGetSourceRef(mh,
                         tcdH,
                         &srefH);
    _res = Py_BuildValue("lO&",
                         _rv,
                         UserDataObj_New, srefH);
    return _res;
}

static PyObject *Qt_TCSetSourceRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    HandlerError _rv;
    MediaHandler mh;
    TimeCodeDescriptionHandle tcdH;
    UserData srefH;
#ifndef TCSetSourceRef
    PyMac_PRECHECK(TCSetSourceRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &mh,
                          ResObj_Convert, &tcdH,
                          UserDataObj_Convert, &srefH))
        return NULL;
    _rv = TCSetSourceRef(mh,
                         tcdH,
                         srefH);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TCSetTimeCodeFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    HandlerError _rv;
    MediaHandler mh;
    long flags;
    long flagsMask;
#ifndef TCSetTimeCodeFlags
    PyMac_PRECHECK(TCSetTimeCodeFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mh,
                          &flags,
                          &flagsMask))
        return NULL;
    _rv = TCSetTimeCodeFlags(mh,
                             flags,
                             flagsMask);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TCGetTimeCodeFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    HandlerError _rv;
    MediaHandler mh;
    long flags;
#ifndef TCGetTimeCodeFlags
    PyMac_PRECHECK(TCGetTimeCodeFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = TCGetTimeCodeFlags(mh,
                             &flags);
    _res = Py_BuildValue("ll",
                         _rv,
                         flags);
    return _res;
}

static PyObject *Qt_MovieImportHandle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    Handle dataH;
    Movie theMovie;
    Track targetTrack;
    Track usedTrack;
    TimeValue atTime;
    TimeValue addedDuration;
    long inFlags;
    long outFlags;
#ifndef MovieImportHandle
    PyMac_PRECHECK(MovieImportHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&ll",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &dataH,
                          MovieObj_Convert, &theMovie,
                          TrackObj_Convert, &targetTrack,
                          &atTime,
                          &inFlags))
        return NULL;
    _rv = MovieImportHandle(ci,
                            dataH,
                            theMovie,
                            targetTrack,
                            &usedTrack,
                            atTime,
                            &addedDuration,
                            inFlags,
                            &outFlags);
    _res = Py_BuildValue("lO&ll",
                         _rv,
                         TrackObj_New, usedTrack,
                         addedDuration,
                         outFlags);
    return _res;
}

static PyObject *Qt_MovieImportFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    FSSpec theFile;
    Movie theMovie;
    Track targetTrack;
    Track usedTrack;
    TimeValue atTime;
    TimeValue addedDuration;
    long inFlags;
    long outFlags;
#ifndef MovieImportFile
    PyMac_PRECHECK(MovieImportFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&ll",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFSSpec, &theFile,
                          MovieObj_Convert, &theMovie,
                          TrackObj_Convert, &targetTrack,
                          &atTime,
                          &inFlags))
        return NULL;
    _rv = MovieImportFile(ci,
                          &theFile,
                          theMovie,
                          targetTrack,
                          &usedTrack,
                          atTime,
                          &addedDuration,
                          inFlags,
                          &outFlags);
    _res = Py_BuildValue("lO&ll",
                         _rv,
                         TrackObj_New, usedTrack,
                         addedDuration,
                         outFlags);
    return _res;
}

static PyObject *Qt_MovieImportSetSampleDuration(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    TimeValue duration;
    TimeScale scale;
#ifndef MovieImportSetSampleDuration
    PyMac_PRECHECK(MovieImportSetSampleDuration);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &ci,
                          &duration,
                          &scale))
        return NULL;
    _rv = MovieImportSetSampleDuration(ci,
                                       duration,
                                       scale);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieImportSetSampleDescription(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    SampleDescriptionHandle desc;
    OSType mediaType;
#ifndef MovieImportSetSampleDescription
    PyMac_PRECHECK(MovieImportSetSampleDescription);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &desc,
                          PyMac_GetOSType, &mediaType))
        return NULL;
    _rv = MovieImportSetSampleDescription(ci,
                                          desc,
                                          mediaType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieImportSetMediaFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    AliasHandle alias;
#ifndef MovieImportSetMediaFile
    PyMac_PRECHECK(MovieImportSetMediaFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &alias))
        return NULL;
    _rv = MovieImportSetMediaFile(ci,
                                  alias);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieImportSetDimensions(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    Fixed width;
    Fixed height;
#ifndef MovieImportSetDimensions
    PyMac_PRECHECK(MovieImportSetDimensions);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFixed, &width,
                          PyMac_GetFixed, &height))
        return NULL;
    _rv = MovieImportSetDimensions(ci,
                                   width,
                                   height);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieImportSetChunkSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    long chunkSize;
#ifndef MovieImportSetChunkSize
    PyMac_PRECHECK(MovieImportSetChunkSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &chunkSize))
        return NULL;
    _rv = MovieImportSetChunkSize(ci,
                                  chunkSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieImportSetAuxiliaryData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    Handle data;
    OSType handleType;
#ifndef MovieImportSetAuxiliaryData
    PyMac_PRECHECK(MovieImportSetAuxiliaryData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &data,
                          PyMac_GetOSType, &handleType))
        return NULL;
    _rv = MovieImportSetAuxiliaryData(ci,
                                      data,
                                      handleType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieImportSetFromScrap(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    Boolean fromScrap;
#ifndef MovieImportSetFromScrap
    PyMac_PRECHECK(MovieImportSetFromScrap);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          CmpInstObj_Convert, &ci,
                          &fromScrap))
        return NULL;
    _rv = MovieImportSetFromScrap(ci,
                                  fromScrap);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieImportDoUserDialog(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    FSSpec theFile;
    Handle theData;
    Boolean canceled;
#ifndef MovieImportDoUserDialog
    PyMac_PRECHECK(MovieImportDoUserDialog);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFSSpec, &theFile,
                          ResObj_Convert, &theData))
        return NULL;
    _rv = MovieImportDoUserDialog(ci,
                                  &theFile,
                                  theData,
                                  &canceled);
    _res = Py_BuildValue("lb",
                         _rv,
                         canceled);
    return _res;
}

static PyObject *Qt_MovieImportSetDuration(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    TimeValue duration;
#ifndef MovieImportSetDuration
    PyMac_PRECHECK(MovieImportSetDuration);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &duration))
        return NULL;
    _rv = MovieImportSetDuration(ci,
                                 duration);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieImportGetAuxiliaryDataType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    OSType auxType;
#ifndef MovieImportGetAuxiliaryDataType
    PyMac_PRECHECK(MovieImportGetAuxiliaryDataType);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = MovieImportGetAuxiliaryDataType(ci,
                                          &auxType);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildOSType, auxType);
    return _res;
}

static PyObject *Qt_MovieImportValidate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    FSSpec theFile;
    Handle theData;
    Boolean valid;
#ifndef MovieImportValidate
    PyMac_PRECHECK(MovieImportValidate);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFSSpec, &theFile,
                          ResObj_Convert, &theData))
        return NULL;
    _rv = MovieImportValidate(ci,
                              &theFile,
                              theData,
                              &valid);
    _res = Py_BuildValue("lb",
                         _rv,
                         valid);
    return _res;
}

static PyObject *Qt_MovieImportGetFileType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    OSType fileType;
#ifndef MovieImportGetFileType
    PyMac_PRECHECK(MovieImportGetFileType);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = MovieImportGetFileType(ci,
                                 &fileType);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildOSType, fileType);
    return _res;
}

static PyObject *Qt_MovieImportDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    Handle dataRef;
    OSType dataRefType;
    Movie theMovie;
    Track targetTrack;
    Track usedTrack;
    TimeValue atTime;
    TimeValue addedDuration;
    long inFlags;
    long outFlags;
#ifndef MovieImportDataRef
    PyMac_PRECHECK(MovieImportDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&O&ll",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType,
                          MovieObj_Convert, &theMovie,
                          TrackObj_Convert, &targetTrack,
                          &atTime,
                          &inFlags))
        return NULL;
    _rv = MovieImportDataRef(ci,
                             dataRef,
                             dataRefType,
                             theMovie,
                             targetTrack,
                             &usedTrack,
                             atTime,
                             &addedDuration,
                             inFlags,
                             &outFlags);
    _res = Py_BuildValue("lO&ll",
                         _rv,
                         TrackObj_New, usedTrack,
                         addedDuration,
                         outFlags);
    return _res;
}

static PyObject *Qt_MovieImportGetSampleDescription(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    SampleDescriptionHandle desc;
    OSType mediaType;
#ifndef MovieImportGetSampleDescription
    PyMac_PRECHECK(MovieImportGetSampleDescription);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = MovieImportGetSampleDescription(ci,
                                          &desc,
                                          &mediaType);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, desc,
                         PyMac_BuildOSType, mediaType);
    return _res;
}

static PyObject *Qt_MovieImportSetOffsetAndLimit(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    unsigned long offset;
    unsigned long limit;
#ifndef MovieImportSetOffsetAndLimit
    PyMac_PRECHECK(MovieImportSetOffsetAndLimit);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &ci,
                          &offset,
                          &limit))
        return NULL;
    _rv = MovieImportSetOffsetAndLimit(ci,
                                       offset,
                                       limit);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieImportSetOffsetAndLimit64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    wide offset;
    wide limit;
#ifndef MovieImportSetOffsetAndLimit64
    PyMac_PRECHECK(MovieImportSetOffsetAndLimit64);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_Getwide, &offset,
                          PyMac_Getwide, &limit))
        return NULL;
    _rv = MovieImportSetOffsetAndLimit64(ci,
                                         &offset,
                                         &limit);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieImportIdle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    long inFlags;
    long outFlags;
#ifndef MovieImportIdle
    PyMac_PRECHECK(MovieImportIdle);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &inFlags))
        return NULL;
    _rv = MovieImportIdle(ci,
                          inFlags,
                          &outFlags);
    _res = Py_BuildValue("ll",
                         _rv,
                         outFlags);
    return _res;
}

static PyObject *Qt_MovieImportValidateDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    Handle dataRef;
    OSType dataRefType;
    UInt8 valid;
#ifndef MovieImportValidateDataRef
    PyMac_PRECHECK(MovieImportValidateDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _rv = MovieImportValidateDataRef(ci,
                                     dataRef,
                                     dataRefType,
                                     &valid);
    _res = Py_BuildValue("lb",
                         _rv,
                         valid);
    return _res;
}

static PyObject *Qt_MovieImportGetLoadState(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    long importerLoadState;
#ifndef MovieImportGetLoadState
    PyMac_PRECHECK(MovieImportGetLoadState);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = MovieImportGetLoadState(ci,
                                  &importerLoadState);
    _res = Py_BuildValue("ll",
                         _rv,
                         importerLoadState);
    return _res;
}

static PyObject *Qt_MovieImportGetMaxLoadedTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    TimeValue time;
#ifndef MovieImportGetMaxLoadedTime
    PyMac_PRECHECK(MovieImportGetMaxLoadedTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = MovieImportGetMaxLoadedTime(ci,
                                      &time);
    _res = Py_BuildValue("ll",
                         _rv,
                         time);
    return _res;
}

static PyObject *Qt_MovieImportEstimateCompletionTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    TimeRecord time;
#ifndef MovieImportEstimateCompletionTime
    PyMac_PRECHECK(MovieImportEstimateCompletionTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = MovieImportEstimateCompletionTime(ci,
                                            &time);
    _res = Py_BuildValue("lO&",
                         _rv,
                         QtTimeRecord_New, &time);
    return _res;
}

static PyObject *Qt_MovieImportSetDontBlock(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    Boolean dontBlock;
#ifndef MovieImportSetDontBlock
    PyMac_PRECHECK(MovieImportSetDontBlock);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          CmpInstObj_Convert, &ci,
                          &dontBlock))
        return NULL;
    _rv = MovieImportSetDontBlock(ci,
                                  dontBlock);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieImportGetDontBlock(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    Boolean willBlock;
#ifndef MovieImportGetDontBlock
    PyMac_PRECHECK(MovieImportGetDontBlock);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = MovieImportGetDontBlock(ci,
                                  &willBlock);
    _res = Py_BuildValue("lb",
                         _rv,
                         willBlock);
    return _res;
}

static PyObject *Qt_MovieImportSetIdleManager(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    IdleManager im;
#ifndef MovieImportSetIdleManager
    PyMac_PRECHECK(MovieImportSetIdleManager);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          IdleManagerObj_Convert, &im))
        return NULL;
    _rv = MovieImportSetIdleManager(ci,
                                    im);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieImportSetNewMovieFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    long newMovieFlags;
#ifndef MovieImportSetNewMovieFlags
    PyMac_PRECHECK(MovieImportSetNewMovieFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &newMovieFlags))
        return NULL;
    _rv = MovieImportSetNewMovieFlags(ci,
                                      newMovieFlags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieImportGetDestinationMediaType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieImportComponent ci;
    OSType mediaType;
#ifndef MovieImportGetDestinationMediaType
    PyMac_PRECHECK(MovieImportGetDestinationMediaType);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = MovieImportGetDestinationMediaType(ci,
                                             &mediaType);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildOSType, mediaType);
    return _res;
}

static PyObject *Qt_MovieExportToHandle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieExportComponent ci;
    Handle dataH;
    Movie theMovie;
    Track onlyThisTrack;
    TimeValue startTime;
    TimeValue duration;
#ifndef MovieExportToHandle
    PyMac_PRECHECK(MovieExportToHandle);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&ll",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &dataH,
                          MovieObj_Convert, &theMovie,
                          TrackObj_Convert, &onlyThisTrack,
                          &startTime,
                          &duration))
        return NULL;
    _rv = MovieExportToHandle(ci,
                              dataH,
                              theMovie,
                              onlyThisTrack,
                              startTime,
                              duration);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieExportToFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieExportComponent ci;
    FSSpec theFile;
    Movie theMovie;
    Track onlyThisTrack;
    TimeValue startTime;
    TimeValue duration;
#ifndef MovieExportToFile
    PyMac_PRECHECK(MovieExportToFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&ll",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFSSpec, &theFile,
                          MovieObj_Convert, &theMovie,
                          TrackObj_Convert, &onlyThisTrack,
                          &startTime,
                          &duration))
        return NULL;
    _rv = MovieExportToFile(ci,
                            &theFile,
                            theMovie,
                            onlyThisTrack,
                            startTime,
                            duration);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieExportGetAuxiliaryData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieExportComponent ci;
    Handle dataH;
    OSType handleType;
#ifndef MovieExportGetAuxiliaryData
    PyMac_PRECHECK(MovieExportGetAuxiliaryData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &dataH))
        return NULL;
    _rv = MovieExportGetAuxiliaryData(ci,
                                      dataH,
                                      &handleType);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildOSType, handleType);
    return _res;
}

static PyObject *Qt_MovieExportSetSampleDescription(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieExportComponent ci;
    SampleDescriptionHandle desc;
    OSType mediaType;
#ifndef MovieExportSetSampleDescription
    PyMac_PRECHECK(MovieExportSetSampleDescription);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &desc,
                          PyMac_GetOSType, &mediaType))
        return NULL;
    _rv = MovieExportSetSampleDescription(ci,
                                          desc,
                                          mediaType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieExportDoUserDialog(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieExportComponent ci;
    Movie theMovie;
    Track onlyThisTrack;
    TimeValue startTime;
    TimeValue duration;
    Boolean canceled;
#ifndef MovieExportDoUserDialog
    PyMac_PRECHECK(MovieExportDoUserDialog);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&ll",
                          CmpInstObj_Convert, &ci,
                          MovieObj_Convert, &theMovie,
                          TrackObj_Convert, &onlyThisTrack,
                          &startTime,
                          &duration))
        return NULL;
    _rv = MovieExportDoUserDialog(ci,
                                  theMovie,
                                  onlyThisTrack,
                                  startTime,
                                  duration,
                                  &canceled);
    _res = Py_BuildValue("lb",
                         _rv,
                         canceled);
    return _res;
}

static PyObject *Qt_MovieExportGetCreatorType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieExportComponent ci;
    OSType creator;
#ifndef MovieExportGetCreatorType
    PyMac_PRECHECK(MovieExportGetCreatorType);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = MovieExportGetCreatorType(ci,
                                    &creator);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildOSType, creator);
    return _res;
}

static PyObject *Qt_MovieExportToDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieExportComponent ci;
    Handle dataRef;
    OSType dataRefType;
    Movie theMovie;
    Track onlyThisTrack;
    TimeValue startTime;
    TimeValue duration;
#ifndef MovieExportToDataRef
    PyMac_PRECHECK(MovieExportToDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&O&ll",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType,
                          MovieObj_Convert, &theMovie,
                          TrackObj_Convert, &onlyThisTrack,
                          &startTime,
                          &duration))
        return NULL;
    _rv = MovieExportToDataRef(ci,
                               dataRef,
                               dataRefType,
                               theMovie,
                               onlyThisTrack,
                               startTime,
                               duration);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieExportFromProceduresToDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieExportComponent ci;
    Handle dataRef;
    OSType dataRefType;
#ifndef MovieExportFromProceduresToDataRef
    PyMac_PRECHECK(MovieExportFromProceduresToDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _rv = MovieExportFromProceduresToDataRef(ci,
                                             dataRef,
                                             dataRefType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieExportValidate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieExportComponent ci;
    Movie theMovie;
    Track onlyThisTrack;
    Boolean valid;
#ifndef MovieExportValidate
    PyMac_PRECHECK(MovieExportValidate);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &ci,
                          MovieObj_Convert, &theMovie,
                          TrackObj_Convert, &onlyThisTrack))
        return NULL;
    _rv = MovieExportValidate(ci,
                              theMovie,
                              onlyThisTrack,
                              &valid);
    _res = Py_BuildValue("lb",
                         _rv,
                         valid);
    return _res;
}

static PyObject *Qt_MovieExportGetFileNameExtension(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieExportComponent ci;
    OSType extension;
#ifndef MovieExportGetFileNameExtension
    PyMac_PRECHECK(MovieExportGetFileNameExtension);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = MovieExportGetFileNameExtension(ci,
                                          &extension);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildOSType, extension);
    return _res;
}

static PyObject *Qt_MovieExportGetShortFileTypeString(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieExportComponent ci;
    Str255 typeString;
#ifndef MovieExportGetShortFileTypeString
    PyMac_PRECHECK(MovieExportGetShortFileTypeString);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetStr255, typeString))
        return NULL;
    _rv = MovieExportGetShortFileTypeString(ci,
                                            typeString);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MovieExportGetSourceMediaType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MovieExportComponent ci;
    OSType mediaType;
#ifndef MovieExportGetSourceMediaType
    PyMac_PRECHECK(MovieExportGetSourceMediaType);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = MovieExportGetSourceMediaType(ci,
                                        &mediaType);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildOSType, mediaType);
    return _res;
}

static PyObject *Qt_TextExportGetTimeFraction(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TextExportComponent ci;
    long movieTimeFraction;
#ifndef TextExportGetTimeFraction
    PyMac_PRECHECK(TextExportGetTimeFraction);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = TextExportGetTimeFraction(ci,
                                    &movieTimeFraction);
    _res = Py_BuildValue("ll",
                         _rv,
                         movieTimeFraction);
    return _res;
}

static PyObject *Qt_TextExportSetTimeFraction(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TextExportComponent ci;
    long movieTimeFraction;
#ifndef TextExportSetTimeFraction
    PyMac_PRECHECK(TextExportSetTimeFraction);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &movieTimeFraction))
        return NULL;
    _rv = TextExportSetTimeFraction(ci,
                                    movieTimeFraction);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TextExportGetSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TextExportComponent ci;
    long setting;
#ifndef TextExportGetSettings
    PyMac_PRECHECK(TextExportGetSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = TextExportGetSettings(ci,
                                &setting);
    _res = Py_BuildValue("ll",
                         _rv,
                         setting);
    return _res;
}

static PyObject *Qt_TextExportSetSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TextExportComponent ci;
    long setting;
#ifndef TextExportSetSettings
    PyMac_PRECHECK(TextExportSetSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &setting))
        return NULL;
    _rv = TextExportSetSettings(ci,
                                setting);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MIDIImportGetSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TextExportComponent ci;
    long setting;
#ifndef MIDIImportGetSettings
    PyMac_PRECHECK(MIDIImportGetSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = MIDIImportGetSettings(ci,
                                &setting);
    _res = Py_BuildValue("ll",
                         _rv,
                         setting);
    return _res;
}

static PyObject *Qt_MIDIImportSetSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TextExportComponent ci;
    long setting;
#ifndef MIDIImportSetSettings
    PyMac_PRECHECK(MIDIImportSetSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &setting))
        return NULL;
    _rv = MIDIImportSetSettings(ci,
                                setting);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImageImportSetSequenceEnabled(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicImageMovieImportComponent ci;
    Boolean enable;
#ifndef GraphicsImageImportSetSequenceEnabled
    PyMac_PRECHECK(GraphicsImageImportSetSequenceEnabled);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          CmpInstObj_Convert, &ci,
                          &enable))
        return NULL;
    _rv = GraphicsImageImportSetSequenceEnabled(ci,
                                                enable);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GraphicsImageImportGetSequenceEnabled(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    GraphicImageMovieImportComponent ci;
    Boolean enable;
#ifndef GraphicsImageImportGetSequenceEnabled
    PyMac_PRECHECK(GraphicsImageImportGetSequenceEnabled);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = GraphicsImageImportGetSequenceEnabled(ci,
                                                &enable);
    _res = Py_BuildValue("lb",
                         _rv,
                         enable);
    return _res;
}

static PyObject *Qt_PreviewShowData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    pnotComponent p;
    OSType dataType;
    Handle data;
    Rect inHere;
#ifndef PreviewShowData
    PyMac_PRECHECK(PreviewShowData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&",
                          CmpInstObj_Convert, &p,
                          PyMac_GetOSType, &dataType,
                          ResObj_Convert, &data,
                          PyMac_GetRect, &inHere))
        return NULL;
    _rv = PreviewShowData(p,
                          dataType,
                          data,
                          &inHere);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_PreviewMakePreviewReference(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    pnotComponent p;
    OSType previewType;
    short resID;
    FSSpec sourceFile;
#ifndef PreviewMakePreviewReference
    PyMac_PRECHECK(PreviewMakePreviewReference);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &p,
                          PyMac_GetFSSpec, &sourceFile))
        return NULL;
    _rv = PreviewMakePreviewReference(p,
                                      &previewType,
                                      &resID,
                                      &sourceFile);
    _res = Py_BuildValue("lO&h",
                         _rv,
                         PyMac_BuildOSType, previewType,
                         resID);
    return _res;
}

static PyObject *Qt_PreviewEvent(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    pnotComponent p;
    EventRecord e;
    Boolean handledEvent;
#ifndef PreviewEvent
    PyMac_PRECHECK(PreviewEvent);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &p))
        return NULL;
    _rv = PreviewEvent(p,
                       &e,
                       &handledEvent);
    _res = Py_BuildValue("lO&b",
                         _rv,
                         PyMac_BuildEventRecord, &e,
                         handledEvent);
    return _res;
}

static PyObject *Qt_DataCodecDecompress(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataCodecComponent dc;
    void * srcData;
    UInt32 srcSize;
    void * dstData;
    UInt32 dstBufferSize;
#ifndef DataCodecDecompress
    PyMac_PRECHECK(DataCodecDecompress);
#endif
    if (!PyArg_ParseTuple(_args, "O&slsl",
                          CmpInstObj_Convert, &dc,
                          &srcData,
                          &srcSize,
                          &dstData,
                          &dstBufferSize))
        return NULL;
    _rv = DataCodecDecompress(dc,
                              srcData,
                              srcSize,
                              dstData,
                              dstBufferSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataCodecGetCompressBufferSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataCodecComponent dc;
    UInt32 srcSize;
    UInt32 dstSize;
#ifndef DataCodecGetCompressBufferSize
    PyMac_PRECHECK(DataCodecGetCompressBufferSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &dc,
                          &srcSize))
        return NULL;
    _rv = DataCodecGetCompressBufferSize(dc,
                                         srcSize,
                                         &dstSize);
    _res = Py_BuildValue("ll",
                         _rv,
                         dstSize);
    return _res;
}

static PyObject *Qt_DataCodecCompress(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataCodecComponent dc;
    void * srcData;
    UInt32 srcSize;
    void * dstData;
    UInt32 dstBufferSize;
    UInt32 actualDstSize;
    UInt32 decompressSlop;
#ifndef DataCodecCompress
    PyMac_PRECHECK(DataCodecCompress);
#endif
    if (!PyArg_ParseTuple(_args, "O&slsl",
                          CmpInstObj_Convert, &dc,
                          &srcData,
                          &srcSize,
                          &dstData,
                          &dstBufferSize))
        return NULL;
    _rv = DataCodecCompress(dc,
                            srcData,
                            srcSize,
                            dstData,
                            dstBufferSize,
                            &actualDstSize,
                            &decompressSlop);
    _res = Py_BuildValue("lll",
                         _rv,
                         actualDstSize,
                         decompressSlop);
    return _res;
}

static PyObject *Qt_DataCodecBeginInterruptSafe(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataCodecComponent dc;
    unsigned long maxSrcSize;
#ifndef DataCodecBeginInterruptSafe
    PyMac_PRECHECK(DataCodecBeginInterruptSafe);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &dc,
                          &maxSrcSize))
        return NULL;
    _rv = DataCodecBeginInterruptSafe(dc,
                                      maxSrcSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataCodecEndInterruptSafe(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataCodecComponent dc;
#ifndef DataCodecEndInterruptSafe
    PyMac_PRECHECK(DataCodecEndInterruptSafe);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dc))
        return NULL;
    _rv = DataCodecEndInterruptSafe(dc);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHGetData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Handle h;
    long hOffset;
    long offset;
    long size;
#ifndef DataHGetData
    PyMac_PRECHECK(DataHGetData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&lll",
                          CmpInstObj_Convert, &dh,
                          ResObj_Convert, &h,
                          &hOffset,
                          &offset,
                          &size))
        return NULL;
    _rv = DataHGetData(dh,
                       h,
                       hOffset,
                       offset,
                       size);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHPutData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Handle h;
    long hOffset;
    long offset;
    long size;
#ifndef DataHPutData
    PyMac_PRECHECK(DataHPutData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&ll",
                          CmpInstObj_Convert, &dh,
                          ResObj_Convert, &h,
                          &hOffset,
                          &size))
        return NULL;
    _rv = DataHPutData(dh,
                       h,
                       hOffset,
                       &offset,
                       size);
    _res = Py_BuildValue("ll",
                         _rv,
                         offset);
    return _res;
}

static PyObject *Qt_DataHFlushData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
#ifndef DataHFlushData
    PyMac_PRECHECK(DataHFlushData);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHFlushData(dh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHOpenForWrite(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
#ifndef DataHOpenForWrite
    PyMac_PRECHECK(DataHOpenForWrite);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHOpenForWrite(dh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHCloseForWrite(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
#ifndef DataHCloseForWrite
    PyMac_PRECHECK(DataHCloseForWrite);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHCloseForWrite(dh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHOpenForRead(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
#ifndef DataHOpenForRead
    PyMac_PRECHECK(DataHOpenForRead);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHOpenForRead(dh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHCloseForRead(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
#ifndef DataHCloseForRead
    PyMac_PRECHECK(DataHCloseForRead);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHCloseForRead(dh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHSetDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Handle dataRef;
#ifndef DataHSetDataRef
    PyMac_PRECHECK(DataHSetDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &dh,
                          ResObj_Convert, &dataRef))
        return NULL;
    _rv = DataHSetDataRef(dh,
                          dataRef);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHGetDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Handle dataRef;
#ifndef DataHGetDataRef
    PyMac_PRECHECK(DataHGetDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetDataRef(dh,
                          &dataRef);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, dataRef);
    return _res;
}

static PyObject *Qt_DataHCompareDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Handle dataRef;
    Boolean equal;
#ifndef DataHCompareDataRef
    PyMac_PRECHECK(DataHCompareDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &dh,
                          ResObj_Convert, &dataRef))
        return NULL;
    _rv = DataHCompareDataRef(dh,
                              dataRef,
                              &equal);
    _res = Py_BuildValue("lb",
                         _rv,
                         equal);
    return _res;
}

static PyObject *Qt_DataHTask(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
#ifndef DataHTask
    PyMac_PRECHECK(DataHTask);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHTask(dh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHFinishData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Ptr PlaceToPutDataPtr;
    Boolean Cancel;
#ifndef DataHFinishData
    PyMac_PRECHECK(DataHFinishData);
#endif
    if (!PyArg_ParseTuple(_args, "O&sb",
                          CmpInstObj_Convert, &dh,
                          &PlaceToPutDataPtr,
                          &Cancel))
        return NULL;
    _rv = DataHFinishData(dh,
                          PlaceToPutDataPtr,
                          Cancel);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHFlushCache(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
#ifndef DataHFlushCache
    PyMac_PRECHECK(DataHFlushCache);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHFlushCache(dh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHResolveDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Handle theDataRef;
    Boolean wasChanged;
    Boolean userInterfaceAllowed;
#ifndef DataHResolveDataRef
    PyMac_PRECHECK(DataHResolveDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&b",
                          CmpInstObj_Convert, &dh,
                          ResObj_Convert, &theDataRef,
                          &userInterfaceAllowed))
        return NULL;
    _rv = DataHResolveDataRef(dh,
                              theDataRef,
                              &wasChanged,
                              userInterfaceAllowed);
    _res = Py_BuildValue("lb",
                         _rv,
                         wasChanged);
    return _res;
}

static PyObject *Qt_DataHGetFileSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long fileSize;
#ifndef DataHGetFileSize
    PyMac_PRECHECK(DataHGetFileSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetFileSize(dh,
                           &fileSize);
    _res = Py_BuildValue("ll",
                         _rv,
                         fileSize);
    return _res;
}

static PyObject *Qt_DataHCanUseDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Handle dataRef;
    long useFlags;
#ifndef DataHCanUseDataRef
    PyMac_PRECHECK(DataHCanUseDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &dh,
                          ResObj_Convert, &dataRef))
        return NULL;
    _rv = DataHCanUseDataRef(dh,
                             dataRef,
                             &useFlags);
    _res = Py_BuildValue("ll",
                         _rv,
                         useFlags);
    return _res;
}

static PyObject *Qt_DataHPreextend(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    unsigned long maxToAdd;
    unsigned long spaceAdded;
#ifndef DataHPreextend
    PyMac_PRECHECK(DataHPreextend);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &dh,
                          &maxToAdd))
        return NULL;
    _rv = DataHPreextend(dh,
                         maxToAdd,
                         &spaceAdded);
    _res = Py_BuildValue("ll",
                         _rv,
                         spaceAdded);
    return _res;
}

static PyObject *Qt_DataHSetFileSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long fileSize;
#ifndef DataHSetFileSize
    PyMac_PRECHECK(DataHSetFileSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &dh,
                          &fileSize))
        return NULL;
    _rv = DataHSetFileSize(dh,
                           fileSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHGetFreeSpace(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    unsigned long freeSize;
#ifndef DataHGetFreeSpace
    PyMac_PRECHECK(DataHGetFreeSpace);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetFreeSpace(dh,
                            &freeSize);
    _res = Py_BuildValue("ll",
                         _rv,
                         freeSize);
    return _res;
}

static PyObject *Qt_DataHCreateFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    OSType creator;
    Boolean deleteExisting;
#ifndef DataHCreateFile
    PyMac_PRECHECK(DataHCreateFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&b",
                          CmpInstObj_Convert, &dh,
                          PyMac_GetOSType, &creator,
                          &deleteExisting))
        return NULL;
    _rv = DataHCreateFile(dh,
                          creator,
                          deleteExisting);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHGetPreferredBlockSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long blockSize;
#ifndef DataHGetPreferredBlockSize
    PyMac_PRECHECK(DataHGetPreferredBlockSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetPreferredBlockSize(dh,
                                     &blockSize);
    _res = Py_BuildValue("ll",
                         _rv,
                         blockSize);
    return _res;
}

static PyObject *Qt_DataHGetDeviceIndex(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long deviceIndex;
#ifndef DataHGetDeviceIndex
    PyMac_PRECHECK(DataHGetDeviceIndex);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetDeviceIndex(dh,
                              &deviceIndex);
    _res = Py_BuildValue("ll",
                         _rv,
                         deviceIndex);
    return _res;
}

static PyObject *Qt_DataHIsStreamingDataHandler(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Boolean yes;
#ifndef DataHIsStreamingDataHandler
    PyMac_PRECHECK(DataHIsStreamingDataHandler);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHIsStreamingDataHandler(dh,
                                      &yes);
    _res = Py_BuildValue("lb",
                         _rv,
                         yes);
    return _res;
}

static PyObject *Qt_DataHGetDataInBuffer(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long startOffset;
    long size;
#ifndef DataHGetDataInBuffer
    PyMac_PRECHECK(DataHGetDataInBuffer);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &dh,
                          &startOffset))
        return NULL;
    _rv = DataHGetDataInBuffer(dh,
                               startOffset,
                               &size);
    _res = Py_BuildValue("ll",
                         _rv,
                         size);
    return _res;
}

static PyObject *Qt_DataHGetScheduleAheadTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long millisecs;
#ifndef DataHGetScheduleAheadTime
    PyMac_PRECHECK(DataHGetScheduleAheadTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetScheduleAheadTime(dh,
                                    &millisecs);
    _res = Py_BuildValue("ll",
                         _rv,
                         millisecs);
    return _res;
}

static PyObject *Qt_DataHSetCacheSizeLimit(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Size cacheSizeLimit;
#ifndef DataHSetCacheSizeLimit
    PyMac_PRECHECK(DataHSetCacheSizeLimit);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &dh,
                          &cacheSizeLimit))
        return NULL;
    _rv = DataHSetCacheSizeLimit(dh,
                                 cacheSizeLimit);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHGetCacheSizeLimit(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Size cacheSizeLimit;
#ifndef DataHGetCacheSizeLimit
    PyMac_PRECHECK(DataHGetCacheSizeLimit);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetCacheSizeLimit(dh,
                                 &cacheSizeLimit);
    _res = Py_BuildValue("ll",
                         _rv,
                         cacheSizeLimit);
    return _res;
}

static PyObject *Qt_DataHGetMovie(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Movie theMovie;
    short id;
#ifndef DataHGetMovie
    PyMac_PRECHECK(DataHGetMovie);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetMovie(dh,
                        &theMovie,
                        &id);
    _res = Py_BuildValue("lO&h",
                         _rv,
                         MovieObj_New, theMovie,
                         id);
    return _res;
}

static PyObject *Qt_DataHAddMovie(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Movie theMovie;
    short id;
#ifndef DataHAddMovie
    PyMac_PRECHECK(DataHAddMovie);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &dh,
                          MovieObj_Convert, &theMovie))
        return NULL;
    _rv = DataHAddMovie(dh,
                        theMovie,
                        &id);
    _res = Py_BuildValue("lh",
                         _rv,
                         id);
    return _res;
}

static PyObject *Qt_DataHUpdateMovie(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Movie theMovie;
    short id;
#ifndef DataHUpdateMovie
    PyMac_PRECHECK(DataHUpdateMovie);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&h",
                          CmpInstObj_Convert, &dh,
                          MovieObj_Convert, &theMovie,
                          &id))
        return NULL;
    _rv = DataHUpdateMovie(dh,
                           theMovie,
                           id);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHDoesBuffer(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Boolean buffersReads;
    Boolean buffersWrites;
#ifndef DataHDoesBuffer
    PyMac_PRECHECK(DataHDoesBuffer);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHDoesBuffer(dh,
                          &buffersReads,
                          &buffersWrites);
    _res = Py_BuildValue("lbb",
                         _rv,
                         buffersReads,
                         buffersWrites);
    return _res;
}

static PyObject *Qt_DataHGetFileName(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Str255 str;
#ifndef DataHGetFileName
    PyMac_PRECHECK(DataHGetFileName);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &dh,
                          PyMac_GetStr255, str))
        return NULL;
    _rv = DataHGetFileName(dh,
                           str);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHGetAvailableFileSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long fileSize;
#ifndef DataHGetAvailableFileSize
    PyMac_PRECHECK(DataHGetAvailableFileSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetAvailableFileSize(dh,
                                    &fileSize);
    _res = Py_BuildValue("ll",
                         _rv,
                         fileSize);
    return _res;
}

static PyObject *Qt_DataHGetMacOSFileType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    OSType fileType;
#ifndef DataHGetMacOSFileType
    PyMac_PRECHECK(DataHGetMacOSFileType);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetMacOSFileType(dh,
                                &fileType);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildOSType, fileType);
    return _res;
}

static PyObject *Qt_DataHGetMIMEType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Str255 mimeType;
#ifndef DataHGetMIMEType
    PyMac_PRECHECK(DataHGetMIMEType);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &dh,
                          PyMac_GetStr255, mimeType))
        return NULL;
    _rv = DataHGetMIMEType(dh,
                           mimeType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHSetDataRefWithAnchor(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Handle anchorDataRef;
    OSType dataRefType;
    Handle dataRef;
#ifndef DataHSetDataRefWithAnchor
    PyMac_PRECHECK(DataHSetDataRefWithAnchor);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&",
                          CmpInstObj_Convert, &dh,
                          ResObj_Convert, &anchorDataRef,
                          PyMac_GetOSType, &dataRefType,
                          ResObj_Convert, &dataRef))
        return NULL;
    _rv = DataHSetDataRefWithAnchor(dh,
                                    anchorDataRef,
                                    dataRefType,
                                    dataRef);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHGetDataRefWithAnchor(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Handle anchorDataRef;
    OSType dataRefType;
    Handle dataRef;
#ifndef DataHGetDataRefWithAnchor
    PyMac_PRECHECK(DataHGetDataRefWithAnchor);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &dh,
                          ResObj_Convert, &anchorDataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _rv = DataHGetDataRefWithAnchor(dh,
                                    anchorDataRef,
                                    dataRefType,
                                    &dataRef);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, dataRef);
    return _res;
}

static PyObject *Qt_DataHSetMacOSFileType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    OSType fileType;
#ifndef DataHSetMacOSFileType
    PyMac_PRECHECK(DataHSetMacOSFileType);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &dh,
                          PyMac_GetOSType, &fileType))
        return NULL;
    _rv = DataHSetMacOSFileType(dh,
                                fileType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHSetTimeBase(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    TimeBase tb;
#ifndef DataHSetTimeBase
    PyMac_PRECHECK(DataHSetTimeBase);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &dh,
                          TimeBaseObj_Convert, &tb))
        return NULL;
    _rv = DataHSetTimeBase(dh,
                           tb);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHGetInfoFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    UInt32 flags;
#ifndef DataHGetInfoFlags
    PyMac_PRECHECK(DataHGetInfoFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetInfoFlags(dh,
                            &flags);
    _res = Py_BuildValue("ll",
                         _rv,
                         flags);
    return _res;
}

static PyObject *Qt_DataHGetFileSize64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    wide fileSize;
#ifndef DataHGetFileSize64
    PyMac_PRECHECK(DataHGetFileSize64);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetFileSize64(dh,
                             &fileSize);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_Buildwide, fileSize);
    return _res;
}

static PyObject *Qt_DataHPreextend64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    wide maxToAdd;
    wide spaceAdded;
#ifndef DataHPreextend64
    PyMac_PRECHECK(DataHPreextend64);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &dh,
                          PyMac_Getwide, &maxToAdd))
        return NULL;
    _rv = DataHPreextend64(dh,
                           &maxToAdd,
                           &spaceAdded);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_Buildwide, spaceAdded);
    return _res;
}

static PyObject *Qt_DataHSetFileSize64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    wide fileSize;
#ifndef DataHSetFileSize64
    PyMac_PRECHECK(DataHSetFileSize64);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &dh,
                          PyMac_Getwide, &fileSize))
        return NULL;
    _rv = DataHSetFileSize64(dh,
                             &fileSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHGetFreeSpace64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    wide freeSize;
#ifndef DataHGetFreeSpace64
    PyMac_PRECHECK(DataHGetFreeSpace64);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetFreeSpace64(dh,
                              &freeSize);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_Buildwide, freeSize);
    return _res;
}

static PyObject *Qt_DataHAppend64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    void * data;
    wide fileOffset;
    unsigned long size;
#ifndef DataHAppend64
    PyMac_PRECHECK(DataHAppend64);
#endif
    if (!PyArg_ParseTuple(_args, "O&sl",
                          CmpInstObj_Convert, &dh,
                          &data,
                          &size))
        return NULL;
    _rv = DataHAppend64(dh,
                        data,
                        &fileOffset,
                        size);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_Buildwide, fileOffset);
    return _res;
}

static PyObject *Qt_DataHPollRead(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    void * dataPtr;
    UInt32 dataSizeSoFar;
#ifndef DataHPollRead
    PyMac_PRECHECK(DataHPollRead);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &dh,
                          &dataPtr))
        return NULL;
    _rv = DataHPollRead(dh,
                        dataPtr,
                        &dataSizeSoFar);
    _res = Py_BuildValue("ll",
                         _rv,
                         dataSizeSoFar);
    return _res;
}

static PyObject *Qt_DataHGetDataAvailability(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long offset;
    long len;
    long missing_offset;
    long missing_len;
#ifndef DataHGetDataAvailability
    PyMac_PRECHECK(DataHGetDataAvailability);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &dh,
                          &offset,
                          &len))
        return NULL;
    _rv = DataHGetDataAvailability(dh,
                                   offset,
                                   len,
                                   &missing_offset,
                                   &missing_len);
    _res = Py_BuildValue("lll",
                         _rv,
                         missing_offset,
                         missing_len);
    return _res;
}

static PyObject *Qt_DataHGetDataRefAsType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    OSType requestedType;
    Handle dataRef;
#ifndef DataHGetDataRefAsType
    PyMac_PRECHECK(DataHGetDataRefAsType);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &dh,
                          PyMac_GetOSType, &requestedType))
        return NULL;
    _rv = DataHGetDataRefAsType(dh,
                                requestedType,
                                &dataRef);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, dataRef);
    return _res;
}

static PyObject *Qt_DataHSetDataRefExtension(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Handle extension;
    OSType idType;
#ifndef DataHSetDataRefExtension
    PyMac_PRECHECK(DataHSetDataRefExtension);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &dh,
                          ResObj_Convert, &extension,
                          PyMac_GetOSType, &idType))
        return NULL;
    _rv = DataHSetDataRefExtension(dh,
                                   extension,
                                   idType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHGetDataRefExtension(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Handle extension;
    OSType idType;
#ifndef DataHGetDataRefExtension
    PyMac_PRECHECK(DataHGetDataRefExtension);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &dh,
                          PyMac_GetOSType, &idType))
        return NULL;
    _rv = DataHGetDataRefExtension(dh,
                                   &extension,
                                   idType);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, extension);
    return _res;
}

static PyObject *Qt_DataHGetMovieWithFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Movie theMovie;
    short id;
    short flags;
#ifndef DataHGetMovieWithFlags
    PyMac_PRECHECK(DataHGetMovieWithFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &dh,
                          &flags))
        return NULL;
    _rv = DataHGetMovieWithFlags(dh,
                                 &theMovie,
                                 &id,
                                 flags);
    _res = Py_BuildValue("lO&h",
                         _rv,
                         MovieObj_New, theMovie,
                         id);
    return _res;
}

static PyObject *Qt_DataHGetFileTypeOrdering(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    DataHFileTypeOrderingHandle orderingListHandle;
#ifndef DataHGetFileTypeOrdering
    PyMac_PRECHECK(DataHGetFileTypeOrdering);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetFileTypeOrdering(dh,
                                   &orderingListHandle);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, orderingListHandle);
    return _res;
}

static PyObject *Qt_DataHCreateFileWithFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    OSType creator;
    Boolean deleteExisting;
    UInt32 flags;
#ifndef DataHCreateFileWithFlags
    PyMac_PRECHECK(DataHCreateFileWithFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&bl",
                          CmpInstObj_Convert, &dh,
                          PyMac_GetOSType, &creator,
                          &deleteExisting,
                          &flags))
        return NULL;
    _rv = DataHCreateFileWithFlags(dh,
                                   creator,
                                   deleteExisting,
                                   flags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHGetInfo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    OSType what;
    void * info;
#ifndef DataHGetInfo
    PyMac_PRECHECK(DataHGetInfo);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&s",
                          CmpInstObj_Convert, &dh,
                          PyMac_GetOSType, &what,
                          &info))
        return NULL;
    _rv = DataHGetInfo(dh,
                       what,
                       info);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHSetIdleManager(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    IdleManager im;
#ifndef DataHSetIdleManager
    PyMac_PRECHECK(DataHSetIdleManager);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &dh,
                          IdleManagerObj_Convert, &im))
        return NULL;
    _rv = DataHSetIdleManager(dh,
                              im);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHDeleteFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
#ifndef DataHDeleteFile
    PyMac_PRECHECK(DataHDeleteFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHDeleteFile(dh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHSetMovieUsageFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long flags;
#ifndef DataHSetMovieUsageFlags
    PyMac_PRECHECK(DataHSetMovieUsageFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &dh,
                          &flags))
        return NULL;
    _rv = DataHSetMovieUsageFlags(dh,
                                  flags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHUseTemporaryDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long inFlags;
#ifndef DataHUseTemporaryDataRef
    PyMac_PRECHECK(DataHUseTemporaryDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &dh,
                          &inFlags))
        return NULL;
    _rv = DataHUseTemporaryDataRef(dh,
                                   inFlags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHGetTemporaryDataRefCapabilities(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long outUnderstoodFlags;
#ifndef DataHGetTemporaryDataRefCapabilities
    PyMac_PRECHECK(DataHGetTemporaryDataRefCapabilities);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &dh))
        return NULL;
    _rv = DataHGetTemporaryDataRefCapabilities(dh,
                                               &outUnderstoodFlags);
    _res = Py_BuildValue("ll",
                         _rv,
                         outUnderstoodFlags);
    return _res;
}

static PyObject *Qt_DataHRenameFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    Handle newDataRef;
#ifndef DataHRenameFile
    PyMac_PRECHECK(DataHRenameFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &dh,
                          ResObj_Convert, &newDataRef))
        return NULL;
    _rv = DataHRenameFile(dh,
                          newDataRef);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHPlaybackHints(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long flags;
    unsigned long minFileOffset;
    unsigned long maxFileOffset;
    long bytesPerSecond;
#ifndef DataHPlaybackHints
    PyMac_PRECHECK(DataHPlaybackHints);
#endif
    if (!PyArg_ParseTuple(_args, "O&llll",
                          CmpInstObj_Convert, &dh,
                          &flags,
                          &minFileOffset,
                          &maxFileOffset,
                          &bytesPerSecond))
        return NULL;
    _rv = DataHPlaybackHints(dh,
                             flags,
                             minFileOffset,
                             maxFileOffset,
                             bytesPerSecond);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHPlaybackHints64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long flags;
    wide minFileOffset;
    wide maxFileOffset;
    long bytesPerSecond;
#ifndef DataHPlaybackHints64
    PyMac_PRECHECK(DataHPlaybackHints64);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&O&l",
                          CmpInstObj_Convert, &dh,
                          &flags,
                          PyMac_Getwide, &minFileOffset,
                          PyMac_Getwide, &maxFileOffset,
                          &bytesPerSecond))
        return NULL;
    _rv = DataHPlaybackHints64(dh,
                               flags,
                               &minFileOffset,
                               &maxFileOffset,
                               bytesPerSecond);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_DataHGetDataRate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long flags;
    long bytesPerSecond;
#ifndef DataHGetDataRate
    PyMac_PRECHECK(DataHGetDataRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &dh,
                          &flags))
        return NULL;
    _rv = DataHGetDataRate(dh,
                           flags,
                           &bytesPerSecond);
    _res = Py_BuildValue("ll",
                         _rv,
                         bytesPerSecond);
    return _res;
}

static PyObject *Qt_DataHSetTimeHints(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    DataHandler dh;
    long flags;
    long bandwidthPriority;
    TimeScale scale;
    TimeValue minTime;
    TimeValue maxTime;
#ifndef DataHSetTimeHints
    PyMac_PRECHECK(DataHSetTimeHints);
#endif
    if (!PyArg_ParseTuple(_args, "O&lllll",
                          CmpInstObj_Convert, &dh,
                          &flags,
                          &bandwidthPriority,
                          &scale,
                          &minTime,
                          &maxTime))
        return NULL;
    _rv = DataHSetTimeHints(dh,
                            flags,
                            bandwidthPriority,
                            scale,
                            minTime,
                            maxTime);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetMaxSrcRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short inputStd;
    Rect maxSrcRect;
#ifndef VDGetMaxSrcRect
    PyMac_PRECHECK(VDGetMaxSrcRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &ci,
                          &inputStd))
        return NULL;
    _rv = VDGetMaxSrcRect(ci,
                          inputStd,
                          &maxSrcRect);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &maxSrcRect);
    return _res;
}

static PyObject *Qt_VDGetActiveSrcRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short inputStd;
    Rect activeSrcRect;
#ifndef VDGetActiveSrcRect
    PyMac_PRECHECK(VDGetActiveSrcRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &ci,
                          &inputStd))
        return NULL;
    _rv = VDGetActiveSrcRect(ci,
                             inputStd,
                             &activeSrcRect);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &activeSrcRect);
    return _res;
}

static PyObject *Qt_VDSetDigitizerRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    Rect digitizerRect;
#ifndef VDSetDigitizerRect
    PyMac_PRECHECK(VDSetDigitizerRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDSetDigitizerRect(ci,
                             &digitizerRect);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &digitizerRect);
    return _res;
}

static PyObject *Qt_VDGetDigitizerRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    Rect digitizerRect;
#ifndef VDGetDigitizerRect
    PyMac_PRECHECK(VDGetDigitizerRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetDigitizerRect(ci,
                             &digitizerRect);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &digitizerRect);
    return _res;
}

static PyObject *Qt_VDGetVBlankRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short inputStd;
    Rect vBlankRect;
#ifndef VDGetVBlankRect
    PyMac_PRECHECK(VDGetVBlankRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &ci,
                          &inputStd))
        return NULL;
    _rv = VDGetVBlankRect(ci,
                          inputStd,
                          &vBlankRect);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &vBlankRect);
    return _res;
}

static PyObject *Qt_VDGetMaskPixMap(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    PixMapHandle maskPixMap;
#ifndef VDGetMaskPixMap
    PyMac_PRECHECK(VDGetMaskPixMap);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &maskPixMap))
        return NULL;
    _rv = VDGetMaskPixMap(ci,
                          maskPixMap);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDUseThisCLUT(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    CTabHandle colorTableHandle;
#ifndef VDUseThisCLUT
    PyMac_PRECHECK(VDUseThisCLUT);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &colorTableHandle))
        return NULL;
    _rv = VDUseThisCLUT(ci,
                        colorTableHandle);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDSetInputGammaValue(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    Fixed channel1;
    Fixed channel2;
    Fixed channel3;
#ifndef VDSetInputGammaValue
    PyMac_PRECHECK(VDSetInputGammaValue);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFixed, &channel1,
                          PyMac_GetFixed, &channel2,
                          PyMac_GetFixed, &channel3))
        return NULL;
    _rv = VDSetInputGammaValue(ci,
                               channel1,
                               channel2,
                               channel3);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetInputGammaValue(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    Fixed channel1;
    Fixed channel2;
    Fixed channel3;
#ifndef VDGetInputGammaValue
    PyMac_PRECHECK(VDGetInputGammaValue);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetInputGammaValue(ci,
                               &channel1,
                               &channel2,
                               &channel3);
    _res = Py_BuildValue("lO&O&O&",
                         _rv,
                         PyMac_BuildFixed, channel1,
                         PyMac_BuildFixed, channel2,
                         PyMac_BuildFixed, channel3);
    return _res;
}

static PyObject *Qt_VDSetBrightness(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short brightness;
#ifndef VDSetBrightness
    PyMac_PRECHECK(VDSetBrightness);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDSetBrightness(ci,
                          &brightness);
    _res = Py_BuildValue("lH",
                         _rv,
                         brightness);
    return _res;
}

static PyObject *Qt_VDGetBrightness(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short brightness;
#ifndef VDGetBrightness
    PyMac_PRECHECK(VDGetBrightness);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetBrightness(ci,
                          &brightness);
    _res = Py_BuildValue("lH",
                         _rv,
                         brightness);
    return _res;
}

static PyObject *Qt_VDSetContrast(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short contrast;
#ifndef VDSetContrast
    PyMac_PRECHECK(VDSetContrast);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDSetContrast(ci,
                        &contrast);
    _res = Py_BuildValue("lH",
                         _rv,
                         contrast);
    return _res;
}

static PyObject *Qt_VDSetHue(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short hue;
#ifndef VDSetHue
    PyMac_PRECHECK(VDSetHue);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDSetHue(ci,
                   &hue);
    _res = Py_BuildValue("lH",
                         _rv,
                         hue);
    return _res;
}

static PyObject *Qt_VDSetSharpness(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short sharpness;
#ifndef VDSetSharpness
    PyMac_PRECHECK(VDSetSharpness);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDSetSharpness(ci,
                         &sharpness);
    _res = Py_BuildValue("lH",
                         _rv,
                         sharpness);
    return _res;
}

static PyObject *Qt_VDSetSaturation(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short saturation;
#ifndef VDSetSaturation
    PyMac_PRECHECK(VDSetSaturation);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDSetSaturation(ci,
                          &saturation);
    _res = Py_BuildValue("lH",
                         _rv,
                         saturation);
    return _res;
}

static PyObject *Qt_VDGetContrast(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short contrast;
#ifndef VDGetContrast
    PyMac_PRECHECK(VDGetContrast);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetContrast(ci,
                        &contrast);
    _res = Py_BuildValue("lH",
                         _rv,
                         contrast);
    return _res;
}

static PyObject *Qt_VDGetHue(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short hue;
#ifndef VDGetHue
    PyMac_PRECHECK(VDGetHue);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetHue(ci,
                   &hue);
    _res = Py_BuildValue("lH",
                         _rv,
                         hue);
    return _res;
}

static PyObject *Qt_VDGetSharpness(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short sharpness;
#ifndef VDGetSharpness
    PyMac_PRECHECK(VDGetSharpness);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetSharpness(ci,
                         &sharpness);
    _res = Py_BuildValue("lH",
                         _rv,
                         sharpness);
    return _res;
}

static PyObject *Qt_VDGetSaturation(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short saturation;
#ifndef VDGetSaturation
    PyMac_PRECHECK(VDGetSaturation);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetSaturation(ci,
                          &saturation);
    _res = Py_BuildValue("lH",
                         _rv,
                         saturation);
    return _res;
}

static PyObject *Qt_VDGrabOneFrame(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
#ifndef VDGrabOneFrame
    PyMac_PRECHECK(VDGrabOneFrame);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGrabOneFrame(ci);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetMaxAuxBuffer(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    PixMapHandle pm;
    Rect r;
#ifndef VDGetMaxAuxBuffer
    PyMac_PRECHECK(VDGetMaxAuxBuffer);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetMaxAuxBuffer(ci,
                            &pm,
                            &r);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, pm,
                         PyMac_BuildRect, &r);
    return _res;
}

static PyObject *Qt_VDGetCurrentFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    long inputCurrentFlag;
    long outputCurrentFlag;
#ifndef VDGetCurrentFlags
    PyMac_PRECHECK(VDGetCurrentFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetCurrentFlags(ci,
                            &inputCurrentFlag,
                            &outputCurrentFlag);
    _res = Py_BuildValue("lll",
                         _rv,
                         inputCurrentFlag,
                         outputCurrentFlag);
    return _res;
}

static PyObject *Qt_VDSetKeyColor(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    long index;
#ifndef VDSetKeyColor
    PyMac_PRECHECK(VDSetKeyColor);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &index))
        return NULL;
    _rv = VDSetKeyColor(ci,
                        index);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetKeyColor(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    long index;
#ifndef VDGetKeyColor
    PyMac_PRECHECK(VDGetKeyColor);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetKeyColor(ci,
                        &index);
    _res = Py_BuildValue("ll",
                         _rv,
                         index);
    return _res;
}

static PyObject *Qt_VDAddKeyColor(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    long index;
#ifndef VDAddKeyColor
    PyMac_PRECHECK(VDAddKeyColor);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDAddKeyColor(ci,
                        &index);
    _res = Py_BuildValue("ll",
                         _rv,
                         index);
    return _res;
}

static PyObject *Qt_VDGetNextKeyColor(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    long index;
#ifndef VDGetNextKeyColor
    PyMac_PRECHECK(VDGetNextKeyColor);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &index))
        return NULL;
    _rv = VDGetNextKeyColor(ci,
                            index);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDSetKeyColorRange(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    RGBColor minRGB;
    RGBColor maxRGB;
#ifndef VDSetKeyColorRange
    PyMac_PRECHECK(VDSetKeyColorRange);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDSetKeyColorRange(ci,
                             &minRGB,
                             &maxRGB);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         QdRGB_New, &minRGB,
                         QdRGB_New, &maxRGB);
    return _res;
}

static PyObject *Qt_VDGetKeyColorRange(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    RGBColor minRGB;
    RGBColor maxRGB;
#ifndef VDGetKeyColorRange
    PyMac_PRECHECK(VDGetKeyColorRange);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetKeyColorRange(ci,
                             &minRGB,
                             &maxRGB);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         QdRGB_New, &minRGB,
                         QdRGB_New, &maxRGB);
    return _res;
}

static PyObject *Qt_VDSetInputColorSpaceMode(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short colorSpaceMode;
#ifndef VDSetInputColorSpaceMode
    PyMac_PRECHECK(VDSetInputColorSpaceMode);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &ci,
                          &colorSpaceMode))
        return NULL;
    _rv = VDSetInputColorSpaceMode(ci,
                                   colorSpaceMode);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetInputColorSpaceMode(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short colorSpaceMode;
#ifndef VDGetInputColorSpaceMode
    PyMac_PRECHECK(VDGetInputColorSpaceMode);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetInputColorSpaceMode(ci,
                                   &colorSpaceMode);
    _res = Py_BuildValue("lh",
                         _rv,
                         colorSpaceMode);
    return _res;
}

static PyObject *Qt_VDSetClipState(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short clipEnable;
#ifndef VDSetClipState
    PyMac_PRECHECK(VDSetClipState);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &ci,
                          &clipEnable))
        return NULL;
    _rv = VDSetClipState(ci,
                         clipEnable);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetClipState(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short clipEnable;
#ifndef VDGetClipState
    PyMac_PRECHECK(VDGetClipState);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetClipState(ci,
                         &clipEnable);
    _res = Py_BuildValue("lh",
                         _rv,
                         clipEnable);
    return _res;
}

static PyObject *Qt_VDSetClipRgn(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    RgnHandle clipRegion;
#ifndef VDSetClipRgn
    PyMac_PRECHECK(VDSetClipRgn);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &clipRegion))
        return NULL;
    _rv = VDSetClipRgn(ci,
                       clipRegion);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDClearClipRgn(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    RgnHandle clipRegion;
#ifndef VDClearClipRgn
    PyMac_PRECHECK(VDClearClipRgn);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &clipRegion))
        return NULL;
    _rv = VDClearClipRgn(ci,
                         clipRegion);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetCLUTInUse(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    CTabHandle colorTableHandle;
#ifndef VDGetCLUTInUse
    PyMac_PRECHECK(VDGetCLUTInUse);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetCLUTInUse(ci,
                         &colorTableHandle);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, colorTableHandle);
    return _res;
}

static PyObject *Qt_VDSetPLLFilterType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short pllType;
#ifndef VDSetPLLFilterType
    PyMac_PRECHECK(VDSetPLLFilterType);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &ci,
                          &pllType))
        return NULL;
    _rv = VDSetPLLFilterType(ci,
                             pllType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetPLLFilterType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short pllType;
#ifndef VDGetPLLFilterType
    PyMac_PRECHECK(VDGetPLLFilterType);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetPLLFilterType(ci,
                             &pllType);
    _res = Py_BuildValue("lh",
                         _rv,
                         pllType);
    return _res;
}

static PyObject *Qt_VDGetMaskandValue(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short blendLevel;
    long mask;
    long value;
#ifndef VDGetMaskandValue
    PyMac_PRECHECK(VDGetMaskandValue);
#endif
    if (!PyArg_ParseTuple(_args, "O&H",
                          CmpInstObj_Convert, &ci,
                          &blendLevel))
        return NULL;
    _rv = VDGetMaskandValue(ci,
                            blendLevel,
                            &mask,
                            &value);
    _res = Py_BuildValue("lll",
                         _rv,
                         mask,
                         value);
    return _res;
}

static PyObject *Qt_VDSetMasterBlendLevel(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short blendLevel;
#ifndef VDSetMasterBlendLevel
    PyMac_PRECHECK(VDSetMasterBlendLevel);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDSetMasterBlendLevel(ci,
                                &blendLevel);
    _res = Py_BuildValue("lH",
                         _rv,
                         blendLevel);
    return _res;
}

static PyObject *Qt_VDSetPlayThruOnOff(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short state;
#ifndef VDSetPlayThruOnOff
    PyMac_PRECHECK(VDSetPlayThruOnOff);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &ci,
                          &state))
        return NULL;
    _rv = VDSetPlayThruOnOff(ci,
                             state);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDSetFieldPreference(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short fieldFlag;
#ifndef VDSetFieldPreference
    PyMac_PRECHECK(VDSetFieldPreference);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &ci,
                          &fieldFlag))
        return NULL;
    _rv = VDSetFieldPreference(ci,
                               fieldFlag);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetFieldPreference(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short fieldFlag;
#ifndef VDGetFieldPreference
    PyMac_PRECHECK(VDGetFieldPreference);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetFieldPreference(ci,
                               &fieldFlag);
    _res = Py_BuildValue("lh",
                         _rv,
                         fieldFlag);
    return _res;
}

static PyObject *Qt_VDPreflightGlobalRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    GrafPtr theWindow;
    Rect globalRect;
#ifndef VDPreflightGlobalRect
    PyMac_PRECHECK(VDPreflightGlobalRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          GrafObj_Convert, &theWindow))
        return NULL;
    _rv = VDPreflightGlobalRect(ci,
                                theWindow,
                                &globalRect);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &globalRect);
    return _res;
}

static PyObject *Qt_VDSetPlayThruGlobalRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    GrafPtr theWindow;
    Rect globalRect;
#ifndef VDSetPlayThruGlobalRect
    PyMac_PRECHECK(VDSetPlayThruGlobalRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          GrafObj_Convert, &theWindow))
        return NULL;
    _rv = VDSetPlayThruGlobalRect(ci,
                                  theWindow,
                                  &globalRect);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &globalRect);
    return _res;
}

static PyObject *Qt_VDSetBlackLevelValue(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short blackLevel;
#ifndef VDSetBlackLevelValue
    PyMac_PRECHECK(VDSetBlackLevelValue);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDSetBlackLevelValue(ci,
                               &blackLevel);
    _res = Py_BuildValue("lH",
                         _rv,
                         blackLevel);
    return _res;
}

static PyObject *Qt_VDGetBlackLevelValue(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short blackLevel;
#ifndef VDGetBlackLevelValue
    PyMac_PRECHECK(VDGetBlackLevelValue);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetBlackLevelValue(ci,
                               &blackLevel);
    _res = Py_BuildValue("lH",
                         _rv,
                         blackLevel);
    return _res;
}

static PyObject *Qt_VDSetWhiteLevelValue(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short whiteLevel;
#ifndef VDSetWhiteLevelValue
    PyMac_PRECHECK(VDSetWhiteLevelValue);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDSetWhiteLevelValue(ci,
                               &whiteLevel);
    _res = Py_BuildValue("lH",
                         _rv,
                         whiteLevel);
    return _res;
}

static PyObject *Qt_VDGetWhiteLevelValue(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short whiteLevel;
#ifndef VDGetWhiteLevelValue
    PyMac_PRECHECK(VDGetWhiteLevelValue);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetWhiteLevelValue(ci,
                               &whiteLevel);
    _res = Py_BuildValue("lH",
                         _rv,
                         whiteLevel);
    return _res;
}

static PyObject *Qt_VDGetVideoDefaults(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    unsigned short blackLevel;
    unsigned short whiteLevel;
    unsigned short brightness;
    unsigned short hue;
    unsigned short saturation;
    unsigned short contrast;
    unsigned short sharpness;
#ifndef VDGetVideoDefaults
    PyMac_PRECHECK(VDGetVideoDefaults);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetVideoDefaults(ci,
                             &blackLevel,
                             &whiteLevel,
                             &brightness,
                             &hue,
                             &saturation,
                             &contrast,
                             &sharpness);
    _res = Py_BuildValue("lHHHHHHH",
                         _rv,
                         blackLevel,
                         whiteLevel,
                         brightness,
                         hue,
                         saturation,
                         contrast,
                         sharpness);
    return _res;
}

static PyObject *Qt_VDGetNumberOfInputs(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short inputs;
#ifndef VDGetNumberOfInputs
    PyMac_PRECHECK(VDGetNumberOfInputs);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetNumberOfInputs(ci,
                              &inputs);
    _res = Py_BuildValue("lh",
                         _rv,
                         inputs);
    return _res;
}

static PyObject *Qt_VDGetInputFormat(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short input;
    short format;
#ifndef VDGetInputFormat
    PyMac_PRECHECK(VDGetInputFormat);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &ci,
                          &input))
        return NULL;
    _rv = VDGetInputFormat(ci,
                           input,
                           &format);
    _res = Py_BuildValue("lh",
                         _rv,
                         format);
    return _res;
}

static PyObject *Qt_VDSetInput(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short input;
#ifndef VDSetInput
    PyMac_PRECHECK(VDSetInput);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &ci,
                          &input))
        return NULL;
    _rv = VDSetInput(ci,
                     input);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetInput(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short input;
#ifndef VDGetInput
    PyMac_PRECHECK(VDGetInput);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetInput(ci,
                     &input);
    _res = Py_BuildValue("lh",
                         _rv,
                         input);
    return _res;
}

static PyObject *Qt_VDSetInputStandard(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short inputStandard;
#ifndef VDSetInputStandard
    PyMac_PRECHECK(VDSetInputStandard);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &ci,
                          &inputStandard))
        return NULL;
    _rv = VDSetInputStandard(ci,
                             inputStandard);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDSetupBuffers(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    VdigBufferRecListHandle bufferList;
#ifndef VDSetupBuffers
    PyMac_PRECHECK(VDSetupBuffers);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &bufferList))
        return NULL;
    _rv = VDSetupBuffers(ci,
                         bufferList);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGrabOneFrameAsync(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short buffer;
#ifndef VDGrabOneFrameAsync
    PyMac_PRECHECK(VDGrabOneFrameAsync);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &ci,
                          &buffer))
        return NULL;
    _rv = VDGrabOneFrameAsync(ci,
                              buffer);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDDone(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    short buffer;
#ifndef VDDone
    PyMac_PRECHECK(VDDone);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &ci,
                          &buffer))
        return NULL;
    _rv = VDDone(ci,
                 buffer);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDSetCompression(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    OSType compressType;
    short depth;
    Rect bounds;
    CodecQ spatialQuality;
    CodecQ temporalQuality;
    long keyFrameRate;
#ifndef VDSetCompression
    PyMac_PRECHECK(VDSetCompression);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&hlll",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetOSType, &compressType,
                          &depth,
                          &spatialQuality,
                          &temporalQuality,
                          &keyFrameRate))
        return NULL;
    _rv = VDSetCompression(ci,
                           compressType,
                           depth,
                           &bounds,
                           spatialQuality,
                           temporalQuality,
                           keyFrameRate);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &bounds);
    return _res;
}

static PyObject *Qt_VDCompressOneFrameAsync(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
#ifndef VDCompressOneFrameAsync
    PyMac_PRECHECK(VDCompressOneFrameAsync);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDCompressOneFrameAsync(ci);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetImageDescription(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    ImageDescriptionHandle desc;
#ifndef VDGetImageDescription
    PyMac_PRECHECK(VDGetImageDescription);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &desc))
        return NULL;
    _rv = VDGetImageDescription(ci,
                                desc);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDResetCompressSequence(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
#ifndef VDResetCompressSequence
    PyMac_PRECHECK(VDResetCompressSequence);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDResetCompressSequence(ci);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDSetCompressionOnOff(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    Boolean state;
#ifndef VDSetCompressionOnOff
    PyMac_PRECHECK(VDSetCompressionOnOff);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          CmpInstObj_Convert, &ci,
                          &state))
        return NULL;
    _rv = VDSetCompressionOnOff(ci,
                                state);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetCompressionTypes(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    VDCompressionListHandle h;
#ifndef VDGetCompressionTypes
    PyMac_PRECHECK(VDGetCompressionTypes);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          ResObj_Convert, &h))
        return NULL;
    _rv = VDGetCompressionTypes(ci,
                                h);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDSetTimeBase(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    TimeBase t;
#ifndef VDSetTimeBase
    PyMac_PRECHECK(VDSetTimeBase);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          TimeBaseObj_Convert, &t))
        return NULL;
    _rv = VDSetTimeBase(ci,
                        t);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDSetFrameRate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    Fixed framesPerSecond;
#ifndef VDSetFrameRate
    PyMac_PRECHECK(VDSetFrameRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetFixed, &framesPerSecond))
        return NULL;
    _rv = VDSetFrameRate(ci,
                         framesPerSecond);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetDataRate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    long milliSecPerFrame;
    Fixed framesPerSecond;
    long bytesPerSecond;
#ifndef VDGetDataRate
    PyMac_PRECHECK(VDGetDataRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetDataRate(ci,
                        &milliSecPerFrame,
                        &framesPerSecond,
                        &bytesPerSecond);
    _res = Py_BuildValue("llO&l",
                         _rv,
                         milliSecPerFrame,
                         PyMac_BuildFixed, framesPerSecond,
                         bytesPerSecond);
    return _res;
}

static PyObject *Qt_VDGetSoundInputDriver(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    Str255 soundDriverName;
#ifndef VDGetSoundInputDriver
    PyMac_PRECHECK(VDGetSoundInputDriver);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetStr255, soundDriverName))
        return NULL;
    _rv = VDGetSoundInputDriver(ci,
                                soundDriverName);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetDMADepths(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    long depthArray;
    long preferredDepth;
#ifndef VDGetDMADepths
    PyMac_PRECHECK(VDGetDMADepths);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetDMADepths(ci,
                         &depthArray,
                         &preferredDepth);
    _res = Py_BuildValue("lll",
                         _rv,
                         depthArray,
                         preferredDepth);
    return _res;
}

static PyObject *Qt_VDGetPreferredTimeScale(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    TimeScale preferred;
#ifndef VDGetPreferredTimeScale
    PyMac_PRECHECK(VDGetPreferredTimeScale);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetPreferredTimeScale(ci,
                                  &preferred);
    _res = Py_BuildValue("ll",
                         _rv,
                         preferred);
    return _res;
}

static PyObject *Qt_VDReleaseAsyncBuffers(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
#ifndef VDReleaseAsyncBuffers
    PyMac_PRECHECK(VDReleaseAsyncBuffers);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDReleaseAsyncBuffers(ci);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDSetDataRate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    long bytesPerSecond;
#ifndef VDSetDataRate
    PyMac_PRECHECK(VDSetDataRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &bytesPerSecond))
        return NULL;
    _rv = VDSetDataRate(ci,
                        bytesPerSecond);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetTimeCode(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    TimeRecord atTime;
    void * timeCodeFormat;
    void * timeCodeTime;
#ifndef VDGetTimeCode
    PyMac_PRECHECK(VDGetTimeCode);
#endif
    if (!PyArg_ParseTuple(_args, "O&ss",
                          CmpInstObj_Convert, &ci,
                          &timeCodeFormat,
                          &timeCodeTime))
        return NULL;
    _rv = VDGetTimeCode(ci,
                        &atTime,
                        timeCodeFormat,
                        timeCodeTime);
    _res = Py_BuildValue("lO&",
                         _rv,
                         QtTimeRecord_New, &atTime);
    return _res;
}

static PyObject *Qt_VDUseSafeBuffers(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    Boolean useSafeBuffers;
#ifndef VDUseSafeBuffers
    PyMac_PRECHECK(VDUseSafeBuffers);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          CmpInstObj_Convert, &ci,
                          &useSafeBuffers))
        return NULL;
    _rv = VDUseSafeBuffers(ci,
                           useSafeBuffers);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetSoundInputSource(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    long videoInput;
    long soundInput;
#ifndef VDGetSoundInputSource
    PyMac_PRECHECK(VDGetSoundInputSource);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &videoInput))
        return NULL;
    _rv = VDGetSoundInputSource(ci,
                                videoInput,
                                &soundInput);
    _res = Py_BuildValue("ll",
                         _rv,
                         soundInput);
    return _res;
}

static PyObject *Qt_VDGetCompressionTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    OSType compressionType;
    short depth;
    Rect srcRect;
    CodecQ spatialQuality;
    CodecQ temporalQuality;
    unsigned long compressTime;
#ifndef VDGetCompressionTime
    PyMac_PRECHECK(VDGetCompressionTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&h",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetOSType, &compressionType,
                          &depth))
        return NULL;
    _rv = VDGetCompressionTime(ci,
                               compressionType,
                               depth,
                               &srcRect,
                               &spatialQuality,
                               &temporalQuality,
                               &compressTime);
    _res = Py_BuildValue("lO&lll",
                         _rv,
                         PyMac_BuildRect, &srcRect,
                         spatialQuality,
                         temporalQuality,
                         compressTime);
    return _res;
}

static PyObject *Qt_VDSetPreferredPacketSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    long preferredPacketSizeInBytes;
#ifndef VDSetPreferredPacketSize
    PyMac_PRECHECK(VDSetPreferredPacketSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &preferredPacketSizeInBytes))
        return NULL;
    _rv = VDSetPreferredPacketSize(ci,
                                   preferredPacketSizeInBytes);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDSetPreferredImageDimensions(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    long width;
    long height;
#ifndef VDSetPreferredImageDimensions
    PyMac_PRECHECK(VDSetPreferredImageDimensions);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &ci,
                          &width,
                          &height))
        return NULL;
    _rv = VDSetPreferredImageDimensions(ci,
                                        width,
                                        height);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetPreferredImageDimensions(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    long width;
    long height;
#ifndef VDGetPreferredImageDimensions
    PyMac_PRECHECK(VDGetPreferredImageDimensions);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = VDGetPreferredImageDimensions(ci,
                                        &width,
                                        &height);
    _res = Py_BuildValue("lll",
                         _rv,
                         width,
                         height);
    return _res;
}

static PyObject *Qt_VDGetInputName(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    long videoInput;
    Str255 name;
#ifndef VDGetInputName
    PyMac_PRECHECK(VDGetInputName);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          CmpInstObj_Convert, &ci,
                          &videoInput,
                          PyMac_GetStr255, name))
        return NULL;
    _rv = VDGetInputName(ci,
                         videoInput,
                         name);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDSetDestinationPort(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    CGrafPtr destPort;
#ifndef VDSetDestinationPort
    PyMac_PRECHECK(VDSetDestinationPort);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          GrafObj_Convert, &destPort))
        return NULL;
    _rv = VDSetDestinationPort(ci,
                               destPort);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_VDGetDeviceNameAndFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    Str255 outName;
    UInt32 outNameFlags;
#ifndef VDGetDeviceNameAndFlags
    PyMac_PRECHECK(VDGetDeviceNameAndFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &ci,
                          PyMac_GetStr255, outName))
        return NULL;
    _rv = VDGetDeviceNameAndFlags(ci,
                                  outName,
                                  &outNameFlags);
    _res = Py_BuildValue("ll",
                         _rv,
                         outNameFlags);
    return _res;
}

static PyObject *Qt_VDCaptureStateChanging(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    VideoDigitizerComponent ci;
    UInt32 inStateFlags;
#ifndef VDCaptureStateChanging
    PyMac_PRECHECK(VDCaptureStateChanging);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &ci,
                          &inStateFlags))
        return NULL;
    _rv = VDCaptureStateChanging(ci,
                                 inStateFlags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_XMLParseGetDetailedParseError(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance aParser;
    long errorLine;
    StringPtr errDesc;
#ifndef XMLParseGetDetailedParseError
    PyMac_PRECHECK(XMLParseGetDetailedParseError);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &aParser,
                          &errDesc))
        return NULL;
    _rv = XMLParseGetDetailedParseError(aParser,
                                        &errorLine,
                                        errDesc);
    _res = Py_BuildValue("ll",
                         _rv,
                         errorLine);
    return _res;
}

static PyObject *Qt_XMLParseAddElement(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance aParser;
    char elementName;
    UInt32 nameSpaceID;
    UInt32 elementID;
    long elementFlags;
#ifndef XMLParseAddElement
    PyMac_PRECHECK(XMLParseAddElement);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &aParser,
                          &nameSpaceID,
                          &elementFlags))
        return NULL;
    _rv = XMLParseAddElement(aParser,
                             &elementName,
                             nameSpaceID,
                             &elementID,
                             elementFlags);
    _res = Py_BuildValue("lcl",
                         _rv,
                         elementName,
                         elementID);
    return _res;
}

static PyObject *Qt_XMLParseAddAttribute(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance aParser;
    UInt32 elementID;
    UInt32 nameSpaceID;
    char attributeName;
    UInt32 attributeID;
#ifndef XMLParseAddAttribute
    PyMac_PRECHECK(XMLParseAddAttribute);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &aParser,
                          &elementID,
                          &nameSpaceID))
        return NULL;
    _rv = XMLParseAddAttribute(aParser,
                               elementID,
                               nameSpaceID,
                               &attributeName,
                               &attributeID);
    _res = Py_BuildValue("lcl",
                         _rv,
                         attributeName,
                         attributeID);
    return _res;
}

static PyObject *Qt_XMLParseAddMultipleAttributes(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance aParser;
    UInt32 elementID;
    UInt32 nameSpaceIDs;
    char attributeNames;
    UInt32 attributeIDs;
#ifndef XMLParseAddMultipleAttributes
    PyMac_PRECHECK(XMLParseAddMultipleAttributes);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &aParser,
                          &elementID))
        return NULL;
    _rv = XMLParseAddMultipleAttributes(aParser,
                                        elementID,
                                        &nameSpaceIDs,
                                        &attributeNames,
                                        &attributeIDs);
    _res = Py_BuildValue("llcl",
                         _rv,
                         nameSpaceIDs,
                         attributeNames,
                         attributeIDs);
    return _res;
}

static PyObject *Qt_XMLParseAddAttributeAndValue(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance aParser;
    UInt32 elementID;
    UInt32 nameSpaceID;
    char attributeName;
    UInt32 attributeID;
    UInt32 attributeValueKind;
    void * attributeValueKindInfo;
#ifndef XMLParseAddAttributeAndValue
    PyMac_PRECHECK(XMLParseAddAttributeAndValue);
#endif
    if (!PyArg_ParseTuple(_args, "O&llls",
                          CmpInstObj_Convert, &aParser,
                          &elementID,
                          &nameSpaceID,
                          &attributeValueKind,
                          &attributeValueKindInfo))
        return NULL;
    _rv = XMLParseAddAttributeAndValue(aParser,
                                       elementID,
                                       nameSpaceID,
                                       &attributeName,
                                       &attributeID,
                                       attributeValueKind,
                                       attributeValueKindInfo);
    _res = Py_BuildValue("lcl",
                         _rv,
                         attributeName,
                         attributeID);
    return _res;
}

static PyObject *Qt_XMLParseAddAttributeValueKind(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance aParser;
    UInt32 elementID;
    UInt32 attributeID;
    UInt32 attributeValueKind;
    void * attributeValueKindInfo;
#ifndef XMLParseAddAttributeValueKind
    PyMac_PRECHECK(XMLParseAddAttributeValueKind);
#endif
    if (!PyArg_ParseTuple(_args, "O&llls",
                          CmpInstObj_Convert, &aParser,
                          &elementID,
                          &attributeID,
                          &attributeValueKind,
                          &attributeValueKindInfo))
        return NULL;
    _rv = XMLParseAddAttributeValueKind(aParser,
                                        elementID,
                                        attributeID,
                                        attributeValueKind,
                                        attributeValueKindInfo);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_XMLParseAddNameSpace(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance aParser;
    char nameSpaceURL;
    UInt32 nameSpaceID;
#ifndef XMLParseAddNameSpace
    PyMac_PRECHECK(XMLParseAddNameSpace);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &aParser))
        return NULL;
    _rv = XMLParseAddNameSpace(aParser,
                               &nameSpaceURL,
                               &nameSpaceID);
    _res = Py_BuildValue("lcl",
                         _rv,
                         nameSpaceURL,
                         nameSpaceID);
    return _res;
}

static PyObject *Qt_XMLParseSetOffsetAndLimit(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance aParser;
    UInt32 offset;
    UInt32 limit;
#ifndef XMLParseSetOffsetAndLimit
    PyMac_PRECHECK(XMLParseSetOffsetAndLimit);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &aParser,
                          &offset,
                          &limit))
        return NULL;
    _rv = XMLParseSetOffsetAndLimit(aParser,
                                    offset,
                                    limit);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_XMLParseSetEventParseRefCon(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    ComponentInstance aParser;
    long refcon;
#ifndef XMLParseSetEventParseRefCon
    PyMac_PRECHECK(XMLParseSetEventParseRefCon);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &aParser,
                          &refcon))
        return NULL;
    _rv = XMLParseSetEventParseRefCon(aParser,
                                      refcon);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGInitialize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
#ifndef SGInitialize
    PyMac_PRECHECK(SGInitialize);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGInitialize(s);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSetDataOutput(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    FSSpec movieFile;
    long whereFlags;
#ifndef SGSetDataOutput
    PyMac_PRECHECK(SGSetDataOutput);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          CmpInstObj_Convert, &s,
                          PyMac_GetFSSpec, &movieFile,
                          &whereFlags))
        return NULL;
    _rv = SGSetDataOutput(s,
                          &movieFile,
                          whereFlags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetDataOutput(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    FSSpec movieFile;
    long whereFlags;
#ifndef SGGetDataOutput
    PyMac_PRECHECK(SGGetDataOutput);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          PyMac_GetFSSpec, &movieFile))
        return NULL;
    _rv = SGGetDataOutput(s,
                          &movieFile,
                          &whereFlags);
    _res = Py_BuildValue("ll",
                         _rv,
                         whereFlags);
    return _res;
}

static PyObject *Qt_SGSetGWorld(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    CGrafPtr gp;
    GDHandle gd;
#ifndef SGSetGWorld
    PyMac_PRECHECK(SGSetGWorld);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &s,
                          GrafObj_Convert, &gp,
                          OptResObj_Convert, &gd))
        return NULL;
    _rv = SGSetGWorld(s,
                      gp,
                      gd);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetGWorld(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    CGrafPtr gp;
    GDHandle gd;
#ifndef SGGetGWorld
    PyMac_PRECHECK(SGGetGWorld);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGGetGWorld(s,
                      &gp,
                      &gd);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         GrafObj_New, gp,
                         OptResObj_New, gd);
    return _res;
}

static PyObject *Qt_SGNewChannel(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    OSType channelType;
    SGChannel ref;
#ifndef SGNewChannel
    PyMac_PRECHECK(SGNewChannel);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          PyMac_GetOSType, &channelType))
        return NULL;
    _rv = SGNewChannel(s,
                       channelType,
                       &ref);
    _res = Py_BuildValue("lO&",
                         _rv,
                         CmpInstObj_New, ref);
    return _res;
}

static PyObject *Qt_SGDisposeChannel(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
#ifndef SGDisposeChannel
    PyMac_PRECHECK(SGDisposeChannel);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGDisposeChannel(s,
                           c);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGStartPreview(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
#ifndef SGStartPreview
    PyMac_PRECHECK(SGStartPreview);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGStartPreview(s);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGStartRecord(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
#ifndef SGStartRecord
    PyMac_PRECHECK(SGStartRecord);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGStartRecord(s);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGIdle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
#ifndef SGIdle
    PyMac_PRECHECK(SGIdle);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGIdle(s);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGStop(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
#ifndef SGStop
    PyMac_PRECHECK(SGStop);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGStop(s);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGPause(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    Boolean pause;
#ifndef SGPause
    PyMac_PRECHECK(SGPause);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          CmpInstObj_Convert, &s,
                          &pause))
        return NULL;
    _rv = SGPause(s,
                  pause);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGPrepare(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    Boolean prepareForPreview;
    Boolean prepareForRecord;
#ifndef SGPrepare
    PyMac_PRECHECK(SGPrepare);
#endif
    if (!PyArg_ParseTuple(_args, "O&bb",
                          CmpInstObj_Convert, &s,
                          &prepareForPreview,
                          &prepareForRecord))
        return NULL;
    _rv = SGPrepare(s,
                    prepareForPreview,
                    prepareForRecord);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGRelease(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
#ifndef SGRelease
    PyMac_PRECHECK(SGRelease);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGRelease(s);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetMovie(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Movie _rv;
    SeqGrabComponent s;
#ifndef SGGetMovie
    PyMac_PRECHECK(SGGetMovie);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGGetMovie(s);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *Qt_SGSetMaximumRecordTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    unsigned long ticks;
#ifndef SGSetMaximumRecordTime
    PyMac_PRECHECK(SGSetMaximumRecordTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &s,
                          &ticks))
        return NULL;
    _rv = SGSetMaximumRecordTime(s,
                                 ticks);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetMaximumRecordTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    unsigned long ticks;
#ifndef SGGetMaximumRecordTime
    PyMac_PRECHECK(SGGetMaximumRecordTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGGetMaximumRecordTime(s,
                                 &ticks);
    _res = Py_BuildValue("ll",
                         _rv,
                         ticks);
    return _res;
}

static PyObject *Qt_SGGetStorageSpaceRemaining(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    unsigned long bytes;
#ifndef SGGetStorageSpaceRemaining
    PyMac_PRECHECK(SGGetStorageSpaceRemaining);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGGetStorageSpaceRemaining(s,
                                     &bytes);
    _res = Py_BuildValue("ll",
                         _rv,
                         bytes);
    return _res;
}

static PyObject *Qt_SGGetTimeRemaining(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    long ticksLeft;
#ifndef SGGetTimeRemaining
    PyMac_PRECHECK(SGGetTimeRemaining);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGGetTimeRemaining(s,
                             &ticksLeft);
    _res = Py_BuildValue("ll",
                         _rv,
                         ticksLeft);
    return _res;
}

static PyObject *Qt_SGGrabPict(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    PicHandle p;
    Rect bounds;
    short offscreenDepth;
    long grabPictFlags;
#ifndef SGGrabPict
    PyMac_PRECHECK(SGGrabPict);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&hl",
                          CmpInstObj_Convert, &s,
                          PyMac_GetRect, &bounds,
                          &offscreenDepth,
                          &grabPictFlags))
        return NULL;
    _rv = SGGrabPict(s,
                     &p,
                     &bounds,
                     offscreenDepth,
                     grabPictFlags);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, p);
    return _res;
}

static PyObject *Qt_SGGetLastMovieResID(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    short resID;
#ifndef SGGetLastMovieResID
    PyMac_PRECHECK(SGGetLastMovieResID);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGGetLastMovieResID(s,
                              &resID);
    _res = Py_BuildValue("lh",
                         _rv,
                         resID);
    return _res;
}

static PyObject *Qt_SGSetFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    long sgFlags;
#ifndef SGSetFlags
    PyMac_PRECHECK(SGSetFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &s,
                          &sgFlags))
        return NULL;
    _rv = SGSetFlags(s,
                     sgFlags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    long sgFlags;
#ifndef SGGetFlags
    PyMac_PRECHECK(SGGetFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGGetFlags(s,
                     &sgFlags);
    _res = Py_BuildValue("ll",
                         _rv,
                         sgFlags);
    return _res;
}

static PyObject *Qt_SGNewChannelFromComponent(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel newChannel;
    Component sgChannelComponent;
#ifndef SGNewChannelFromComponent
    PyMac_PRECHECK(SGNewChannelFromComponent);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          CmpObj_Convert, &sgChannelComponent))
        return NULL;
    _rv = SGNewChannelFromComponent(s,
                                    &newChannel,
                                    sgChannelComponent);
    _res = Py_BuildValue("lO&",
                         _rv,
                         CmpInstObj_New, newChannel);
    return _res;
}

static PyObject *Qt_SGSetSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    UserData ud;
    long flags;
#ifndef SGSetSettings
    PyMac_PRECHECK(SGSetSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          CmpInstObj_Convert, &s,
                          UserDataObj_Convert, &ud,
                          &flags))
        return NULL;
    _rv = SGSetSettings(s,
                        ud,
                        flags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    UserData ud;
    long flags;
#ifndef SGGetSettings
    PyMac_PRECHECK(SGGetSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &s,
                          &flags))
        return NULL;
    _rv = SGGetSettings(s,
                        &ud,
                        flags);
    _res = Py_BuildValue("lO&",
                         _rv,
                         UserDataObj_New, ud);
    return _res;
}

static PyObject *Qt_SGGetIndChannel(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    short index;
    SGChannel ref;
    OSType chanType;
#ifndef SGGetIndChannel
    PyMac_PRECHECK(SGGetIndChannel);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &s,
                          &index))
        return NULL;
    _rv = SGGetIndChannel(s,
                          index,
                          &ref,
                          &chanType);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         CmpInstObj_New, ref,
                         PyMac_BuildOSType, chanType);
    return _res;
}

static PyObject *Qt_SGUpdate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    RgnHandle updateRgn;
#ifndef SGUpdate
    PyMac_PRECHECK(SGUpdate);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          ResObj_Convert, &updateRgn))
        return NULL;
    _rv = SGUpdate(s,
                   updateRgn);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetPause(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    Boolean paused;
#ifndef SGGetPause
    PyMac_PRECHECK(SGGetPause);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGGetPause(s,
                     &paused);
    _res = Py_BuildValue("lb",
                         _rv,
                         paused);
    return _res;
}

static PyObject *Qt_SGSetChannelSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
    UserData ud;
    long flags;
#ifndef SGSetChannelSettings
    PyMac_PRECHECK(SGSetChannelSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&l",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c,
                          UserDataObj_Convert, &ud,
                          &flags))
        return NULL;
    _rv = SGSetChannelSettings(s,
                               c,
                               ud,
                               flags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetChannelSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
    UserData ud;
    long flags;
#ifndef SGGetChannelSettings
    PyMac_PRECHECK(SGGetChannelSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c,
                          &flags))
        return NULL;
    _rv = SGGetChannelSettings(s,
                               c,
                               &ud,
                               flags);
    _res = Py_BuildValue("lO&",
                         _rv,
                         UserDataObj_New, ud);
    return _res;
}

static PyObject *Qt_SGGetMode(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    Boolean previewMode;
    Boolean recordMode;
#ifndef SGGetMode
    PyMac_PRECHECK(SGGetMode);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGGetMode(s,
                    &previewMode,
                    &recordMode);
    _res = Py_BuildValue("lbb",
                         _rv,
                         previewMode,
                         recordMode);
    return _res;
}

static PyObject *Qt_SGSetDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    Handle dataRef;
    OSType dataRefType;
    long whereFlags;
#ifndef SGSetDataRef
    PyMac_PRECHECK(SGSetDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&l",
                          CmpInstObj_Convert, &s,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType,
                          &whereFlags))
        return NULL;
    _rv = SGSetDataRef(s,
                       dataRef,
                       dataRefType,
                       whereFlags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetDataRef(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    Handle dataRef;
    OSType dataRefType;
    long whereFlags;
#ifndef SGGetDataRef
    PyMac_PRECHECK(SGGetDataRef);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGGetDataRef(s,
                       &dataRef,
                       &dataRefType,
                       &whereFlags);
    _res = Py_BuildValue("lO&O&l",
                         _rv,
                         ResObj_New, dataRef,
                         PyMac_BuildOSType, dataRefType,
                         whereFlags);
    return _res;
}

static PyObject *Qt_SGNewOutput(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    Handle dataRef;
    OSType dataRefType;
    long whereFlags;
    SGOutput sgOut;
#ifndef SGNewOutput
    PyMac_PRECHECK(SGNewOutput);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&l",
                          CmpInstObj_Convert, &s,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType,
                          &whereFlags))
        return NULL;
    _rv = SGNewOutput(s,
                      dataRef,
                      dataRefType,
                      whereFlags,
                      &sgOut);
    _res = Py_BuildValue("lO&",
                         _rv,
                         SGOutputObj_New, sgOut);
    return _res;
}

static PyObject *Qt_SGDisposeOutput(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGOutput sgOut;
#ifndef SGDisposeOutput
    PyMac_PRECHECK(SGDisposeOutput);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          SGOutputObj_Convert, &sgOut))
        return NULL;
    _rv = SGDisposeOutput(s,
                          sgOut);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSetOutputFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGOutput sgOut;
    long whereFlags;
#ifndef SGSetOutputFlags
    PyMac_PRECHECK(SGSetOutputFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          CmpInstObj_Convert, &s,
                          SGOutputObj_Convert, &sgOut,
                          &whereFlags))
        return NULL;
    _rv = SGSetOutputFlags(s,
                           sgOut,
                           whereFlags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSetChannelOutput(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
    SGOutput sgOut;
#ifndef SGSetChannelOutput
    PyMac_PRECHECK(SGSetChannelOutput);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c,
                          SGOutputObj_Convert, &sgOut))
        return NULL;
    _rv = SGSetChannelOutput(s,
                             c,
                             sgOut);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetDataOutputStorageSpaceRemaining(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGOutput sgOut;
    unsigned long space;
#ifndef SGGetDataOutputStorageSpaceRemaining
    PyMac_PRECHECK(SGGetDataOutputStorageSpaceRemaining);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          SGOutputObj_Convert, &sgOut))
        return NULL;
    _rv = SGGetDataOutputStorageSpaceRemaining(s,
                                               sgOut,
                                               &space);
    _res = Py_BuildValue("ll",
                         _rv,
                         space);
    return _res;
}

static PyObject *Qt_SGHandleUpdateEvent(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    EventRecord event;
    Boolean handled;
#ifndef SGHandleUpdateEvent
    PyMac_PRECHECK(SGHandleUpdateEvent);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          PyMac_GetEventRecord, &event))
        return NULL;
    _rv = SGHandleUpdateEvent(s,
                              &event,
                              &handled);
    _res = Py_BuildValue("lb",
                         _rv,
                         handled);
    return _res;
}

static PyObject *Qt_SGSetOutputNextOutput(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGOutput sgOut;
    SGOutput nextOut;
#ifndef SGSetOutputNextOutput
    PyMac_PRECHECK(SGSetOutputNextOutput);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &s,
                          SGOutputObj_Convert, &sgOut,
                          SGOutputObj_Convert, &nextOut))
        return NULL;
    _rv = SGSetOutputNextOutput(s,
                                sgOut,
                                nextOut);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetOutputNextOutput(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGOutput sgOut;
    SGOutput nextOut;
#ifndef SGGetOutputNextOutput
    PyMac_PRECHECK(SGGetOutputNextOutput);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          SGOutputObj_Convert, &sgOut))
        return NULL;
    _rv = SGGetOutputNextOutput(s,
                                sgOut,
                                &nextOut);
    _res = Py_BuildValue("lO&",
                         _rv,
                         SGOutputObj_New, nextOut);
    return _res;
}

static PyObject *Qt_SGSetOutputMaximumOffset(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGOutput sgOut;
    wide maxOffset;
#ifndef SGSetOutputMaximumOffset
    PyMac_PRECHECK(SGSetOutputMaximumOffset);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &s,
                          SGOutputObj_Convert, &sgOut,
                          PyMac_Getwide, &maxOffset))
        return NULL;
    _rv = SGSetOutputMaximumOffset(s,
                                   sgOut,
                                   &maxOffset);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetOutputMaximumOffset(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGOutput sgOut;
    wide maxOffset;
#ifndef SGGetOutputMaximumOffset
    PyMac_PRECHECK(SGGetOutputMaximumOffset);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          SGOutputObj_Convert, &sgOut))
        return NULL;
    _rv = SGGetOutputMaximumOffset(s,
                                   sgOut,
                                   &maxOffset);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_Buildwide, maxOffset);
    return _res;
}

static PyObject *Qt_SGGetOutputDataReference(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGOutput sgOut;
    Handle dataRef;
    OSType dataRefType;
#ifndef SGGetOutputDataReference
    PyMac_PRECHECK(SGGetOutputDataReference);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          SGOutputObj_Convert, &sgOut))
        return NULL;
    _rv = SGGetOutputDataReference(s,
                                   sgOut,
                                   &dataRef,
                                   &dataRefType);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, dataRef,
                         PyMac_BuildOSType, dataRefType);
    return _res;
}

static PyObject *Qt_SGWriteExtendedMovieData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
    Ptr p;
    long len;
    wide offset;
    SGOutput sgOut;
#ifndef SGWriteExtendedMovieData
    PyMac_PRECHECK(SGWriteExtendedMovieData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&sl",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c,
                          &p,
                          &len))
        return NULL;
    _rv = SGWriteExtendedMovieData(s,
                                   c,
                                   p,
                                   len,
                                   &offset,
                                   &sgOut);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         PyMac_Buildwide, offset,
                         SGOutputObj_New, sgOut);
    return _res;
}

static PyObject *Qt_SGGetStorageSpaceRemaining64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    wide bytes;
#ifndef SGGetStorageSpaceRemaining64
    PyMac_PRECHECK(SGGetStorageSpaceRemaining64);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGGetStorageSpaceRemaining64(s,
                                       &bytes);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_Buildwide, bytes);
    return _res;
}

static PyObject *Qt_SGGetDataOutputStorageSpaceRemaining64(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGOutput sgOut;
    wide space;
#ifndef SGGetDataOutputStorageSpaceRemaining64
    PyMac_PRECHECK(SGGetDataOutputStorageSpaceRemaining64);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          SGOutputObj_Convert, &sgOut))
        return NULL;
    _rv = SGGetDataOutputStorageSpaceRemaining64(s,
                                                 sgOut,
                                                 &space);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_Buildwide, space);
    return _res;
}

static PyObject *Qt_SGWriteMovieData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
    Ptr p;
    long len;
    long offset;
#ifndef SGWriteMovieData
    PyMac_PRECHECK(SGWriteMovieData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&sl",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c,
                          &p,
                          &len))
        return NULL;
    _rv = SGWriteMovieData(s,
                           c,
                           p,
                           len,
                           &offset);
    _res = Py_BuildValue("ll",
                         _rv,
                         offset);
    return _res;
}

static PyObject *Qt_SGGetTimeBase(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    TimeBase tb;
#ifndef SGGetTimeBase
    PyMac_PRECHECK(SGGetTimeBase);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGGetTimeBase(s,
                        &tb);
    _res = Py_BuildValue("lO&",
                         _rv,
                         TimeBaseObj_New, tb);
    return _res;
}

static PyObject *Qt_SGAddMovieData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
    Ptr p;
    long len;
    long offset;
    long chRefCon;
    TimeValue time;
    short writeType;
#ifndef SGAddMovieData
    PyMac_PRECHECK(SGAddMovieData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&slllh",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c,
                          &p,
                          &len,
                          &chRefCon,
                          &time,
                          &writeType))
        return NULL;
    _rv = SGAddMovieData(s,
                         c,
                         p,
                         len,
                         &offset,
                         chRefCon,
                         time,
                         writeType);
    _res = Py_BuildValue("ll",
                         _rv,
                         offset);
    return _res;
}

static PyObject *Qt_SGChangedSource(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
#ifndef SGChangedSource
    PyMac_PRECHECK(SGChangedSource);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGChangedSource(s,
                          c);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGAddExtendedMovieData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
    Ptr p;
    long len;
    wide offset;
    long chRefCon;
    TimeValue time;
    short writeType;
    SGOutput whichOutput;
#ifndef SGAddExtendedMovieData
    PyMac_PRECHECK(SGAddExtendedMovieData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&slllh",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c,
                          &p,
                          &len,
                          &chRefCon,
                          &time,
                          &writeType))
        return NULL;
    _rv = SGAddExtendedMovieData(s,
                                 c,
                                 p,
                                 len,
                                 &offset,
                                 chRefCon,
                                 time,
                                 writeType,
                                 &whichOutput);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         PyMac_Buildwide, offset,
                         SGOutputObj_New, whichOutput);
    return _res;
}

static PyObject *Qt_SGAddOutputDataRefToMedia(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGOutput sgOut;
    Media theMedia;
    SampleDescriptionHandle desc;
#ifndef SGAddOutputDataRefToMedia
    PyMac_PRECHECK(SGAddOutputDataRefToMedia);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&O&",
                          CmpInstObj_Convert, &s,
                          SGOutputObj_Convert, &sgOut,
                          MediaObj_Convert, &theMedia,
                          ResObj_Convert, &desc))
        return NULL;
    _rv = SGAddOutputDataRefToMedia(s,
                                    sgOut,
                                    theMedia,
                                    desc);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSetSettingsSummary(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    Handle summaryText;
#ifndef SGSetSettingsSummary
    PyMac_PRECHECK(SGSetSettingsSummary);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          ResObj_Convert, &summaryText))
        return NULL;
    _rv = SGSetSettingsSummary(s,
                               summaryText);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSetChannelUsage(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long usage;
#ifndef SGSetChannelUsage
    PyMac_PRECHECK(SGSetChannelUsage);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &c,
                          &usage))
        return NULL;
    _rv = SGSetChannelUsage(c,
                            usage);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetChannelUsage(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long usage;
#ifndef SGGetChannelUsage
    PyMac_PRECHECK(SGGetChannelUsage);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetChannelUsage(c,
                            &usage);
    _res = Py_BuildValue("ll",
                         _rv,
                         usage);
    return _res;
}

static PyObject *Qt_SGSetChannelBounds(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Rect bounds;
#ifndef SGSetChannelBounds
    PyMac_PRECHECK(SGSetChannelBounds);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &c,
                          PyMac_GetRect, &bounds))
        return NULL;
    _rv = SGSetChannelBounds(c,
                             &bounds);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetChannelBounds(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Rect bounds;
#ifndef SGGetChannelBounds
    PyMac_PRECHECK(SGGetChannelBounds);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetChannelBounds(c,
                             &bounds);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &bounds);
    return _res;
}

static PyObject *Qt_SGSetChannelVolume(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short volume;
#ifndef SGSetChannelVolume
    PyMac_PRECHECK(SGSetChannelVolume);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &c,
                          &volume))
        return NULL;
    _rv = SGSetChannelVolume(c,
                             volume);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetChannelVolume(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short volume;
#ifndef SGGetChannelVolume
    PyMac_PRECHECK(SGGetChannelVolume);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetChannelVolume(c,
                             &volume);
    _res = Py_BuildValue("lh",
                         _rv,
                         volume);
    return _res;
}

static PyObject *Qt_SGGetChannelInfo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long channelInfo;
#ifndef SGGetChannelInfo
    PyMac_PRECHECK(SGGetChannelInfo);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetChannelInfo(c,
                           &channelInfo);
    _res = Py_BuildValue("ll",
                         _rv,
                         channelInfo);
    return _res;
}

static PyObject *Qt_SGSetChannelPlayFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long playFlags;
#ifndef SGSetChannelPlayFlags
    PyMac_PRECHECK(SGSetChannelPlayFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &c,
                          &playFlags))
        return NULL;
    _rv = SGSetChannelPlayFlags(c,
                                playFlags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetChannelPlayFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long playFlags;
#ifndef SGGetChannelPlayFlags
    PyMac_PRECHECK(SGGetChannelPlayFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetChannelPlayFlags(c,
                                &playFlags);
    _res = Py_BuildValue("ll",
                         _rv,
                         playFlags);
    return _res;
}

static PyObject *Qt_SGSetChannelMaxFrames(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long frameCount;
#ifndef SGSetChannelMaxFrames
    PyMac_PRECHECK(SGSetChannelMaxFrames);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &c,
                          &frameCount))
        return NULL;
    _rv = SGSetChannelMaxFrames(c,
                                frameCount);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetChannelMaxFrames(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long frameCount;
#ifndef SGGetChannelMaxFrames
    PyMac_PRECHECK(SGGetChannelMaxFrames);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetChannelMaxFrames(c,
                                &frameCount);
    _res = Py_BuildValue("ll",
                         _rv,
                         frameCount);
    return _res;
}

static PyObject *Qt_SGSetChannelRefCon(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long refCon;
#ifndef SGSetChannelRefCon
    PyMac_PRECHECK(SGSetChannelRefCon);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &c,
                          &refCon))
        return NULL;
    _rv = SGSetChannelRefCon(c,
                             refCon);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSetChannelClip(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    RgnHandle theClip;
#ifndef SGSetChannelClip
    PyMac_PRECHECK(SGSetChannelClip);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &c,
                          ResObj_Convert, &theClip))
        return NULL;
    _rv = SGSetChannelClip(c,
                           theClip);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetChannelClip(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    RgnHandle theClip;
#ifndef SGGetChannelClip
    PyMac_PRECHECK(SGGetChannelClip);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetChannelClip(c,
                           &theClip);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, theClip);
    return _res;
}

static PyObject *Qt_SGGetChannelSampleDescription(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Handle sampleDesc;
#ifndef SGGetChannelSampleDescription
    PyMac_PRECHECK(SGGetChannelSampleDescription);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &c,
                          ResObj_Convert, &sampleDesc))
        return NULL;
    _rv = SGGetChannelSampleDescription(c,
                                        sampleDesc);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSetChannelDevice(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    StringPtr name;
#ifndef SGSetChannelDevice
    PyMac_PRECHECK(SGSetChannelDevice);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &c,
                          &name))
        return NULL;
    _rv = SGSetChannelDevice(c,
                             name);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetChannelTimeScale(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    TimeScale scale;
#ifndef SGGetChannelTimeScale
    PyMac_PRECHECK(SGGetChannelTimeScale);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetChannelTimeScale(c,
                                &scale);
    _res = Py_BuildValue("ll",
                         _rv,
                         scale);
    return _res;
}

static PyObject *Qt_SGChannelPutPicture(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
#ifndef SGChannelPutPicture
    PyMac_PRECHECK(SGChannelPutPicture);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGChannelPutPicture(c);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGChannelSetRequestedDataRate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long bytesPerSecond;
#ifndef SGChannelSetRequestedDataRate
    PyMac_PRECHECK(SGChannelSetRequestedDataRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &c,
                          &bytesPerSecond))
        return NULL;
    _rv = SGChannelSetRequestedDataRate(c,
                                        bytesPerSecond);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGChannelGetRequestedDataRate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long bytesPerSecond;
#ifndef SGChannelGetRequestedDataRate
    PyMac_PRECHECK(SGChannelGetRequestedDataRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGChannelGetRequestedDataRate(c,
                                        &bytesPerSecond);
    _res = Py_BuildValue("ll",
                         _rv,
                         bytesPerSecond);
    return _res;
}

static PyObject *Qt_SGChannelSetDataSourceName(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Str255 name;
    ScriptCode scriptTag;
#ifndef SGChannelSetDataSourceName
    PyMac_PRECHECK(SGChannelSetDataSourceName);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&h",
                          CmpInstObj_Convert, &c,
                          PyMac_GetStr255, name,
                          &scriptTag))
        return NULL;
    _rv = SGChannelSetDataSourceName(c,
                                     name,
                                     scriptTag);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGChannelGetDataSourceName(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Str255 name;
    ScriptCode scriptTag;
#ifndef SGChannelGetDataSourceName
    PyMac_PRECHECK(SGChannelGetDataSourceName);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &c,
                          PyMac_GetStr255, name))
        return NULL;
    _rv = SGChannelGetDataSourceName(c,
                                     name,
                                     &scriptTag);
    _res = Py_BuildValue("lh",
                         _rv,
                         scriptTag);
    return _res;
}

static PyObject *Qt_SGChannelSetCodecSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Handle settings;
#ifndef SGChannelSetCodecSettings
    PyMac_PRECHECK(SGChannelSetCodecSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &c,
                          ResObj_Convert, &settings))
        return NULL;
    _rv = SGChannelSetCodecSettings(c,
                                    settings);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGChannelGetCodecSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Handle settings;
#ifndef SGChannelGetCodecSettings
    PyMac_PRECHECK(SGChannelGetCodecSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGChannelGetCodecSettings(c,
                                    &settings);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, settings);
    return _res;
}

static PyObject *Qt_SGGetChannelTimeBase(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    TimeBase tb;
#ifndef SGGetChannelTimeBase
    PyMac_PRECHECK(SGGetChannelTimeBase);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetChannelTimeBase(c,
                               &tb);
    _res = Py_BuildValue("lO&",
                         _rv,
                         TimeBaseObj_New, tb);
    return _res;
}

static PyObject *Qt_SGGetChannelRefCon(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long refCon;
#ifndef SGGetChannelRefCon
    PyMac_PRECHECK(SGGetChannelRefCon);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetChannelRefCon(c,
                             &refCon);
    _res = Py_BuildValue("ll",
                         _rv,
                         refCon);
    return _res;
}

static PyObject *Qt_SGGetChannelDeviceAndInputNames(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Str255 outDeviceName;
    Str255 outInputName;
    short outInputNumber;
#ifndef SGGetChannelDeviceAndInputNames
    PyMac_PRECHECK(SGGetChannelDeviceAndInputNames);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &c,
                          PyMac_GetStr255, outDeviceName,
                          PyMac_GetStr255, outInputName))
        return NULL;
    _rv = SGGetChannelDeviceAndInputNames(c,
                                          outDeviceName,
                                          outInputName,
                                          &outInputNumber);
    _res = Py_BuildValue("lh",
                         _rv,
                         outInputNumber);
    return _res;
}

static PyObject *Qt_SGSetChannelDeviceInput(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short inInputNumber;
#ifndef SGSetChannelDeviceInput
    PyMac_PRECHECK(SGSetChannelDeviceInput);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &c,
                          &inInputNumber))
        return NULL;
    _rv = SGSetChannelDeviceInput(c,
                                  inInputNumber);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSetChannelSettingsStateChanging(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    UInt32 inFlags;
#ifndef SGSetChannelSettingsStateChanging
    PyMac_PRECHECK(SGSetChannelSettingsStateChanging);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &c,
                          &inFlags))
        return NULL;
    _rv = SGSetChannelSettingsStateChanging(c,
                                            inFlags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGInitChannel(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    SeqGrabComponent owner;
#ifndef SGInitChannel
    PyMac_PRECHECK(SGInitChannel);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &c,
                          CmpInstObj_Convert, &owner))
        return NULL;
    _rv = SGInitChannel(c,
                        owner);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGWriteSamples(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Movie m;
    AliasHandle theFile;
#ifndef SGWriteSamples
    PyMac_PRECHECK(SGWriteSamples);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &c,
                          MovieObj_Convert, &m,
                          ResObj_Convert, &theFile))
        return NULL;
    _rv = SGWriteSamples(c,
                         m,
                         theFile);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetDataRate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long bytesPerSecond;
#ifndef SGGetDataRate
    PyMac_PRECHECK(SGGetDataRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetDataRate(c,
                        &bytesPerSecond);
    _res = Py_BuildValue("ll",
                         _rv,
                         bytesPerSecond);
    return _res;
}

static PyObject *Qt_SGAlignChannelRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Rect r;
#ifndef SGAlignChannelRect
    PyMac_PRECHECK(SGAlignChannelRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGAlignChannelRect(c,
                             &r);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &r);
    return _res;
}

static PyObject *Qt_SGPanelGetDitl(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    Handle ditl;
#ifndef SGPanelGetDitl
    PyMac_PRECHECK(SGPanelGetDitl);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGPanelGetDitl(s,
                         &ditl);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, ditl);
    return _res;
}

static PyObject *Qt_SGPanelGetTitle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    Str255 title;
#ifndef SGPanelGetTitle
    PyMac_PRECHECK(SGPanelGetTitle);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          PyMac_GetStr255, title))
        return NULL;
    _rv = SGPanelGetTitle(s,
                          title);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGPanelCanRun(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
#ifndef SGPanelCanRun
    PyMac_PRECHECK(SGPanelCanRun);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGPanelCanRun(s,
                        c);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGPanelInstall(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
    DialogPtr d;
    short itemOffset;
#ifndef SGPanelInstall
    PyMac_PRECHECK(SGPanelInstall);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&h",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c,
                          DlgObj_Convert, &d,
                          &itemOffset))
        return NULL;
    _rv = SGPanelInstall(s,
                         c,
                         d,
                         itemOffset);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGPanelEvent(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
    DialogPtr d;
    short itemOffset;
    EventRecord theEvent;
    short itemHit;
    Boolean handled;
#ifndef SGPanelEvent
    PyMac_PRECHECK(SGPanelEvent);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&hO&",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c,
                          DlgObj_Convert, &d,
                          &itemOffset,
                          PyMac_GetEventRecord, &theEvent))
        return NULL;
    _rv = SGPanelEvent(s,
                       c,
                       d,
                       itemOffset,
                       &theEvent,
                       &itemHit,
                       &handled);
    _res = Py_BuildValue("lhb",
                         _rv,
                         itemHit,
                         handled);
    return _res;
}

static PyObject *Qt_SGPanelItem(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
    DialogPtr d;
    short itemOffset;
    short itemNum;
#ifndef SGPanelItem
    PyMac_PRECHECK(SGPanelItem);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&hh",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c,
                          DlgObj_Convert, &d,
                          &itemOffset,
                          &itemNum))
        return NULL;
    _rv = SGPanelItem(s,
                      c,
                      d,
                      itemOffset,
                      itemNum);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGPanelRemove(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
    DialogPtr d;
    short itemOffset;
#ifndef SGPanelRemove
    PyMac_PRECHECK(SGPanelRemove);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&h",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c,
                          DlgObj_Convert, &d,
                          &itemOffset))
        return NULL;
    _rv = SGPanelRemove(s,
                        c,
                        d,
                        itemOffset);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGPanelSetGrabber(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SeqGrabComponent sg;
#ifndef SGPanelSetGrabber
    PyMac_PRECHECK(SGPanelSetGrabber);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &sg))
        return NULL;
    _rv = SGPanelSetGrabber(s,
                            sg);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGPanelSetResFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    short resRef;
#ifndef SGPanelSetResFile
    PyMac_PRECHECK(SGPanelSetResFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &s,
                          &resRef))
        return NULL;
    _rv = SGPanelSetResFile(s,
                            resRef);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGPanelGetSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
    UserData ud;
    long flags;
#ifndef SGPanelGetSettings
    PyMac_PRECHECK(SGPanelGetSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c,
                          &flags))
        return NULL;
    _rv = SGPanelGetSettings(s,
                             c,
                             &ud,
                             flags);
    _res = Py_BuildValue("lO&",
                         _rv,
                         UserDataObj_New, ud);
    return _res;
}

static PyObject *Qt_SGPanelSetSettings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    SGChannel c;
    UserData ud;
    long flags;
#ifndef SGPanelSetSettings
    PyMac_PRECHECK(SGPanelSetSettings);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&l",
                          CmpInstObj_Convert, &s,
                          CmpInstObj_Convert, &c,
                          UserDataObj_Convert, &ud,
                          &flags))
        return NULL;
    _rv = SGPanelSetSettings(s,
                             c,
                             ud,
                             flags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGPanelValidateInput(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    Boolean ok;
#ifndef SGPanelValidateInput
    PyMac_PRECHECK(SGPanelValidateInput);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGPanelValidateInput(s,
                               &ok);
    _res = Py_BuildValue("lb",
                         _rv,
                         ok);
    return _res;
}

static PyObject *Qt_SGPanelGetDITLForSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SeqGrabComponent s;
    Handle ditl;
    Point requestedSize;
#ifndef SGPanelGetDITLForSize
    PyMac_PRECHECK(SGPanelGetDITLForSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &s))
        return NULL;
    _rv = SGPanelGetDITLForSize(s,
                                &ditl,
                                &requestedSize);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, ditl,
                         PyMac_BuildPoint, requestedSize);
    return _res;
}

static PyObject *Qt_SGGetSrcVideoBounds(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Rect r;
#ifndef SGGetSrcVideoBounds
    PyMac_PRECHECK(SGGetSrcVideoBounds);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetSrcVideoBounds(c,
                              &r);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &r);
    return _res;
}

static PyObject *Qt_SGSetVideoRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Rect r;
#ifndef SGSetVideoRect
    PyMac_PRECHECK(SGSetVideoRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &c,
                          PyMac_GetRect, &r))
        return NULL;
    _rv = SGSetVideoRect(c,
                         &r);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetVideoRect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Rect r;
#ifndef SGGetVideoRect
    PyMac_PRECHECK(SGGetVideoRect);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetVideoRect(c,
                         &r);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &r);
    return _res;
}

static PyObject *Qt_SGGetVideoCompressorType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    OSType compressorType;
#ifndef SGGetVideoCompressorType
    PyMac_PRECHECK(SGGetVideoCompressorType);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetVideoCompressorType(c,
                                   &compressorType);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildOSType, compressorType);
    return _res;
}

static PyObject *Qt_SGSetVideoCompressorType(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    OSType compressorType;
#ifndef SGSetVideoCompressorType
    PyMac_PRECHECK(SGSetVideoCompressorType);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &c,
                          PyMac_GetOSType, &compressorType))
        return NULL;
    _rv = SGSetVideoCompressorType(c,
                                   compressorType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSetVideoCompressor(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short depth;
    CompressorComponent compressor;
    CodecQ spatialQuality;
    CodecQ temporalQuality;
    long keyFrameRate;
#ifndef SGSetVideoCompressor
    PyMac_PRECHECK(SGSetVideoCompressor);
#endif
    if (!PyArg_ParseTuple(_args, "O&hO&lll",
                          CmpInstObj_Convert, &c,
                          &depth,
                          CmpObj_Convert, &compressor,
                          &spatialQuality,
                          &temporalQuality,
                          &keyFrameRate))
        return NULL;
    _rv = SGSetVideoCompressor(c,
                               depth,
                               compressor,
                               spatialQuality,
                               temporalQuality,
                               keyFrameRate);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetVideoCompressor(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short depth;
    CompressorComponent compressor;
    CodecQ spatialQuality;
    CodecQ temporalQuality;
    long keyFrameRate;
#ifndef SGGetVideoCompressor
    PyMac_PRECHECK(SGGetVideoCompressor);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetVideoCompressor(c,
                               &depth,
                               &compressor,
                               &spatialQuality,
                               &temporalQuality,
                               &keyFrameRate);
    _res = Py_BuildValue("lhO&lll",
                         _rv,
                         depth,
                         CmpObj_New, compressor,
                         spatialQuality,
                         temporalQuality,
                         keyFrameRate);
    return _res;
}

static PyObject *Qt_SGGetVideoDigitizerComponent(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentInstance _rv;
    SGChannel c;
#ifndef SGGetVideoDigitizerComponent
    PyMac_PRECHECK(SGGetVideoDigitizerComponent);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetVideoDigitizerComponent(c);
    _res = Py_BuildValue("O&",
                         CmpInstObj_New, _rv);
    return _res;
}

static PyObject *Qt_SGSetVideoDigitizerComponent(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    ComponentInstance vdig;
#ifndef SGSetVideoDigitizerComponent
    PyMac_PRECHECK(SGSetVideoDigitizerComponent);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &c,
                          CmpInstObj_Convert, &vdig))
        return NULL;
    _rv = SGSetVideoDigitizerComponent(c,
                                       vdig);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGVideoDigitizerChanged(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
#ifndef SGVideoDigitizerChanged
    PyMac_PRECHECK(SGVideoDigitizerChanged);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGVideoDigitizerChanged(c);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGrabFrame(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short bufferNum;
#ifndef SGGrabFrame
    PyMac_PRECHECK(SGGrabFrame);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &c,
                          &bufferNum))
        return NULL;
    _rv = SGGrabFrame(c,
                      bufferNum);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGrabFrameComplete(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short bufferNum;
    Boolean done;
#ifndef SGGrabFrameComplete
    PyMac_PRECHECK(SGGrabFrameComplete);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &c,
                          &bufferNum))
        return NULL;
    _rv = SGGrabFrameComplete(c,
                              bufferNum,
                              &done);
    _res = Py_BuildValue("lb",
                         _rv,
                         done);
    return _res;
}

static PyObject *Qt_SGCompressFrame(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short bufferNum;
#ifndef SGCompressFrame
    PyMac_PRECHECK(SGCompressFrame);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &c,
                          &bufferNum))
        return NULL;
    _rv = SGCompressFrame(c,
                          bufferNum);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSetCompressBuffer(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short depth;
    Rect compressSize;
#ifndef SGSetCompressBuffer
    PyMac_PRECHECK(SGSetCompressBuffer);
#endif
    if (!PyArg_ParseTuple(_args, "O&hO&",
                          CmpInstObj_Convert, &c,
                          &depth,
                          PyMac_GetRect, &compressSize))
        return NULL;
    _rv = SGSetCompressBuffer(c,
                              depth,
                              &compressSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetCompressBuffer(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short depth;
    Rect compressSize;
#ifndef SGGetCompressBuffer
    PyMac_PRECHECK(SGGetCompressBuffer);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetCompressBuffer(c,
                              &depth,
                              &compressSize);
    _res = Py_BuildValue("lhO&",
                         _rv,
                         depth,
                         PyMac_BuildRect, &compressSize);
    return _res;
}

static PyObject *Qt_SGGetBufferInfo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short bufferNum;
    PixMapHandle bufferPM;
    Rect bufferRect;
    GWorldPtr compressBuffer;
    Rect compressBufferRect;
#ifndef SGGetBufferInfo
    PyMac_PRECHECK(SGGetBufferInfo);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &c,
                          &bufferNum))
        return NULL;
    _rv = SGGetBufferInfo(c,
                          bufferNum,
                          &bufferPM,
                          &bufferRect,
                          &compressBuffer,
                          &compressBufferRect);
    _res = Py_BuildValue("lO&O&O&O&",
                         _rv,
                         ResObj_New, bufferPM,
                         PyMac_BuildRect, &bufferRect,
                         GWorldObj_New, compressBuffer,
                         PyMac_BuildRect, &compressBufferRect);
    return _res;
}

static PyObject *Qt_SGSetUseScreenBuffer(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Boolean useScreenBuffer;
#ifndef SGSetUseScreenBuffer
    PyMac_PRECHECK(SGSetUseScreenBuffer);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          CmpInstObj_Convert, &c,
                          &useScreenBuffer))
        return NULL;
    _rv = SGSetUseScreenBuffer(c,
                               useScreenBuffer);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetUseScreenBuffer(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Boolean useScreenBuffer;
#ifndef SGGetUseScreenBuffer
    PyMac_PRECHECK(SGGetUseScreenBuffer);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetUseScreenBuffer(c,
                               &useScreenBuffer);
    _res = Py_BuildValue("lb",
                         _rv,
                         useScreenBuffer);
    return _res;
}

static PyObject *Qt_SGSetFrameRate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Fixed frameRate;
#ifndef SGSetFrameRate
    PyMac_PRECHECK(SGSetFrameRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &c,
                          PyMac_GetFixed, &frameRate))
        return NULL;
    _rv = SGSetFrameRate(c,
                         frameRate);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetFrameRate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Fixed frameRate;
#ifndef SGGetFrameRate
    PyMac_PRECHECK(SGGetFrameRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetFrameRate(c,
                         &frameRate);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildFixed, frameRate);
    return _res;
}

static PyObject *Qt_SGSetPreferredPacketSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long preferredPacketSizeInBytes;
#ifndef SGSetPreferredPacketSize
    PyMac_PRECHECK(SGSetPreferredPacketSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &c,
                          &preferredPacketSizeInBytes))
        return NULL;
    _rv = SGSetPreferredPacketSize(c,
                                   preferredPacketSizeInBytes);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetPreferredPacketSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long preferredPacketSizeInBytes;
#ifndef SGGetPreferredPacketSize
    PyMac_PRECHECK(SGGetPreferredPacketSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetPreferredPacketSize(c,
                                   &preferredPacketSizeInBytes);
    _res = Py_BuildValue("ll",
                         _rv,
                         preferredPacketSizeInBytes);
    return _res;
}

static PyObject *Qt_SGSetUserVideoCompressorList(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Handle compressorTypes;
#ifndef SGSetUserVideoCompressorList
    PyMac_PRECHECK(SGSetUserVideoCompressorList);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &c,
                          ResObj_Convert, &compressorTypes))
        return NULL;
    _rv = SGSetUserVideoCompressorList(c,
                                       compressorTypes);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetUserVideoCompressorList(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Handle compressorTypes;
#ifndef SGGetUserVideoCompressorList
    PyMac_PRECHECK(SGGetUserVideoCompressorList);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetUserVideoCompressorList(c,
                                       &compressorTypes);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, compressorTypes);
    return _res;
}

static PyObject *Qt_SGSetSoundInputDriver(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Str255 driverName;
#ifndef SGSetSoundInputDriver
    PyMac_PRECHECK(SGSetSoundInputDriver);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &c,
                          PyMac_GetStr255, driverName))
        return NULL;
    _rv = SGSetSoundInputDriver(c,
                                driverName);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetSoundInputDriver(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
    SGChannel c;
#ifndef SGGetSoundInputDriver
    PyMac_PRECHECK(SGGetSoundInputDriver);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetSoundInputDriver(c);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSoundInputDriverChanged(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
#ifndef SGSoundInputDriverChanged
    PyMac_PRECHECK(SGSoundInputDriverChanged);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGSoundInputDriverChanged(c);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSetSoundRecordChunkSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    long seconds;
#ifndef SGSetSoundRecordChunkSize
    PyMac_PRECHECK(SGSetSoundRecordChunkSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &c,
                          &seconds))
        return NULL;
    _rv = SGSetSoundRecordChunkSize(c,
                                    seconds);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetSoundRecordChunkSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
    SGChannel c;
#ifndef SGGetSoundRecordChunkSize
    PyMac_PRECHECK(SGGetSoundRecordChunkSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetSoundRecordChunkSize(c);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSetSoundInputRate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Fixed rate;
#ifndef SGSetSoundInputRate
    PyMac_PRECHECK(SGSetSoundInputRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &c,
                          PyMac_GetFixed, &rate))
        return NULL;
    _rv = SGSetSoundInputRate(c,
                              rate);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetSoundInputRate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Fixed _rv;
    SGChannel c;
#ifndef SGGetSoundInputRate
    PyMac_PRECHECK(SGGetSoundInputRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetSoundInputRate(c);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *Qt_SGSetSoundInputParameters(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short sampleSize;
    short numChannels;
    OSType compressionType;
#ifndef SGSetSoundInputParameters
    PyMac_PRECHECK(SGSetSoundInputParameters);
#endif
    if (!PyArg_ParseTuple(_args, "O&hhO&",
                          CmpInstObj_Convert, &c,
                          &sampleSize,
                          &numChannels,
                          PyMac_GetOSType, &compressionType))
        return NULL;
    _rv = SGSetSoundInputParameters(c,
                                    sampleSize,
                                    numChannels,
                                    compressionType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetSoundInputParameters(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short sampleSize;
    short numChannels;
    OSType compressionType;
#ifndef SGGetSoundInputParameters
    PyMac_PRECHECK(SGGetSoundInputParameters);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetSoundInputParameters(c,
                                    &sampleSize,
                                    &numChannels,
                                    &compressionType);
    _res = Py_BuildValue("lhhO&",
                         _rv,
                         sampleSize,
                         numChannels,
                         PyMac_BuildOSType, compressionType);
    return _res;
}

static PyObject *Qt_SGSetAdditionalSoundRates(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Handle rates;
#ifndef SGSetAdditionalSoundRates
    PyMac_PRECHECK(SGSetAdditionalSoundRates);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &c,
                          ResObj_Convert, &rates))
        return NULL;
    _rv = SGSetAdditionalSoundRates(c,
                                    rates);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetAdditionalSoundRates(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    Handle rates;
#ifndef SGGetAdditionalSoundRates
    PyMac_PRECHECK(SGGetAdditionalSoundRates);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetAdditionalSoundRates(c,
                                    &rates);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, rates);
    return _res;
}

static PyObject *Qt_SGSetFontName(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    StringPtr pstr;
#ifndef SGSetFontName
    PyMac_PRECHECK(SGSetFontName);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &c,
                          &pstr))
        return NULL;
    _rv = SGSetFontName(c,
                        pstr);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSetFontSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short fontSize;
#ifndef SGSetFontSize
    PyMac_PRECHECK(SGSetFontSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &c,
                          &fontSize))
        return NULL;
    _rv = SGSetFontSize(c,
                        fontSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGSetTextForeColor(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    RGBColor theColor;
#ifndef SGSetTextForeColor
    PyMac_PRECHECK(SGSetTextForeColor);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGSetTextForeColor(c,
                             &theColor);
    _res = Py_BuildValue("lO&",
                         _rv,
                         QdRGB_New, &theColor);
    return _res;
}

static PyObject *Qt_SGSetTextBackColor(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    RGBColor theColor;
#ifndef SGSetTextBackColor
    PyMac_PRECHECK(SGSetTextBackColor);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGSetTextBackColor(c,
                             &theColor);
    _res = Py_BuildValue("lO&",
                         _rv,
                         QdRGB_New, &theColor);
    return _res;
}

static PyObject *Qt_SGSetJustification(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short just;
#ifndef SGSetJustification
    PyMac_PRECHECK(SGSetJustification);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &c,
                          &just))
        return NULL;
    _rv = SGSetJustification(c,
                             just);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_SGGetTextReturnToSpaceValue(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short rettospace;
#ifndef SGGetTextReturnToSpaceValue
    PyMac_PRECHECK(SGGetTextReturnToSpaceValue);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &c))
        return NULL;
    _rv = SGGetTextReturnToSpaceValue(c,
                                      &rettospace);
    _res = Py_BuildValue("lh",
                         _rv,
                         rettospace);
    return _res;
}

static PyObject *Qt_SGSetTextReturnToSpaceValue(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SGChannel c;
    short rettospace;
#ifndef SGSetTextReturnToSpaceValue
    PyMac_PRECHECK(SGSetTextReturnToSpaceValue);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &c,
                          &rettospace))
        return NULL;
    _rv = SGSetTextReturnToSpaceValue(c,
                                      rettospace);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_QTVideoOutputGetCurrentClientName(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTVideoOutputComponent vo;
    Str255 str;
#ifndef QTVideoOutputGetCurrentClientName
    PyMac_PRECHECK(QTVideoOutputGetCurrentClientName);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &vo,
                          PyMac_GetStr255, str))
        return NULL;
    _rv = QTVideoOutputGetCurrentClientName(vo,
                                            str);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_QTVideoOutputSetClientName(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTVideoOutputComponent vo;
    Str255 str;
#ifndef QTVideoOutputSetClientName
    PyMac_PRECHECK(QTVideoOutputSetClientName);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &vo,
                          PyMac_GetStr255, str))
        return NULL;
    _rv = QTVideoOutputSetClientName(vo,
                                     str);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_QTVideoOutputGetClientName(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTVideoOutputComponent vo;
    Str255 str;
#ifndef QTVideoOutputGetClientName
    PyMac_PRECHECK(QTVideoOutputGetClientName);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &vo,
                          PyMac_GetStr255, str))
        return NULL;
    _rv = QTVideoOutputGetClientName(vo,
                                     str);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_QTVideoOutputBegin(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTVideoOutputComponent vo;
#ifndef QTVideoOutputBegin
    PyMac_PRECHECK(QTVideoOutputBegin);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &vo))
        return NULL;
    _rv = QTVideoOutputBegin(vo);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_QTVideoOutputEnd(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTVideoOutputComponent vo;
#ifndef QTVideoOutputEnd
    PyMac_PRECHECK(QTVideoOutputEnd);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &vo))
        return NULL;
    _rv = QTVideoOutputEnd(vo);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_QTVideoOutputSetDisplayMode(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTVideoOutputComponent vo;
    long displayModeID;
#ifndef QTVideoOutputSetDisplayMode
    PyMac_PRECHECK(QTVideoOutputSetDisplayMode);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &vo,
                          &displayModeID))
        return NULL;
    _rv = QTVideoOutputSetDisplayMode(vo,
                                      displayModeID);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_QTVideoOutputGetDisplayMode(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTVideoOutputComponent vo;
    long displayModeID;
#ifndef QTVideoOutputGetDisplayMode
    PyMac_PRECHECK(QTVideoOutputGetDisplayMode);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &vo))
        return NULL;
    _rv = QTVideoOutputGetDisplayMode(vo,
                                      &displayModeID);
    _res = Py_BuildValue("ll",
                         _rv,
                         displayModeID);
    return _res;
}

static PyObject *Qt_QTVideoOutputGetGWorld(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTVideoOutputComponent vo;
    GWorldPtr gw;
#ifndef QTVideoOutputGetGWorld
    PyMac_PRECHECK(QTVideoOutputGetGWorld);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &vo))
        return NULL;
    _rv = QTVideoOutputGetGWorld(vo,
                                 &gw);
    _res = Py_BuildValue("lO&",
                         _rv,
                         GWorldObj_New, gw);
    return _res;
}

static PyObject *Qt_QTVideoOutputGetIndSoundOutput(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTVideoOutputComponent vo;
    long index;
    Component outputComponent;
#ifndef QTVideoOutputGetIndSoundOutput
    PyMac_PRECHECK(QTVideoOutputGetIndSoundOutput);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &vo,
                          &index))
        return NULL;
    _rv = QTVideoOutputGetIndSoundOutput(vo,
                                         index,
                                         &outputComponent);
    _res = Py_BuildValue("lO&",
                         _rv,
                         CmpObj_New, outputComponent);
    return _res;
}

static PyObject *Qt_QTVideoOutputGetClock(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTVideoOutputComponent vo;
    ComponentInstance clock;
#ifndef QTVideoOutputGetClock
    PyMac_PRECHECK(QTVideoOutputGetClock);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &vo))
        return NULL;
    _rv = QTVideoOutputGetClock(vo,
                                &clock);
    _res = Py_BuildValue("lO&",
                         _rv,
                         CmpInstObj_New, clock);
    return _res;
}

static PyObject *Qt_QTVideoOutputSetEchoPort(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTVideoOutputComponent vo;
    CGrafPtr echoPort;
#ifndef QTVideoOutputSetEchoPort
    PyMac_PRECHECK(QTVideoOutputSetEchoPort);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &vo,
                          GrafObj_Convert, &echoPort))
        return NULL;
    _rv = QTVideoOutputSetEchoPort(vo,
                                   echoPort);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_QTVideoOutputGetIndImageDecompressor(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTVideoOutputComponent vo;
    long index;
    Component codec;
#ifndef QTVideoOutputGetIndImageDecompressor
    PyMac_PRECHECK(QTVideoOutputGetIndImageDecompressor);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &vo,
                          &index))
        return NULL;
    _rv = QTVideoOutputGetIndImageDecompressor(vo,
                                               index,
                                               &codec);
    _res = Py_BuildValue("lO&",
                         _rv,
                         CmpObj_New, codec);
    return _res;
}

static PyObject *Qt_QTVideoOutputBaseSetEchoPort(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTVideoOutputComponent vo;
    CGrafPtr echoPort;
#ifndef QTVideoOutputBaseSetEchoPort
    PyMac_PRECHECK(QTVideoOutputBaseSetEchoPort);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &vo,
                          GrafObj_Convert, &echoPort))
        return NULL;
    _rv = QTVideoOutputBaseSetEchoPort(vo,
                                       echoPort);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSetChunkManagementFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    UInt32 flags;
    UInt32 flagsMask;
#ifndef MediaSetChunkManagementFlags
    PyMac_PRECHECK(MediaSetChunkManagementFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mh,
                          &flags,
                          &flagsMask))
        return NULL;
    _rv = MediaSetChunkManagementFlags(mh,
                                       flags,
                                       flagsMask);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetChunkManagementFlags(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    UInt32 flags;
#ifndef MediaGetChunkManagementFlags
    PyMac_PRECHECK(MediaGetChunkManagementFlags);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetChunkManagementFlags(mh,
                                       &flags);
    _res = Py_BuildValue("ll",
                         _rv,
                         flags);
    return _res;
}

static PyObject *Qt_MediaSetPurgeableChunkMemoryAllowance(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Size allowance;
#ifndef MediaSetPurgeableChunkMemoryAllowance
    PyMac_PRECHECK(MediaSetPurgeableChunkMemoryAllowance);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &allowance))
        return NULL;
    _rv = MediaSetPurgeableChunkMemoryAllowance(mh,
                                                allowance);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetPurgeableChunkMemoryAllowance(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Size allowance;
#ifndef MediaGetPurgeableChunkMemoryAllowance
    PyMac_PRECHECK(MediaGetPurgeableChunkMemoryAllowance);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetPurgeableChunkMemoryAllowance(mh,
                                                &allowance);
    _res = Py_BuildValue("ll",
                         _rv,
                         allowance);
    return _res;
}

static PyObject *Qt_MediaEmptyAllPurgeableChunks(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
#ifndef MediaEmptyAllPurgeableChunks
    PyMac_PRECHECK(MediaEmptyAllPurgeableChunks);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaEmptyAllPurgeableChunks(mh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSetHandlerCapabilities(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long flags;
    long flagsMask;
#ifndef MediaSetHandlerCapabilities
    PyMac_PRECHECK(MediaSetHandlerCapabilities);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mh,
                          &flags,
                          &flagsMask))
        return NULL;
    _rv = MediaSetHandlerCapabilities(mh,
                                      flags,
                                      flagsMask);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaIdle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    TimeValue atMediaTime;
    long flagsIn;
    long flagsOut;
    TimeRecord movieTime;
#ifndef MediaIdle
    PyMac_PRECHECK(MediaIdle);
#endif
    if (!PyArg_ParseTuple(_args, "O&llO&",
                          CmpInstObj_Convert, &mh,
                          &atMediaTime,
                          &flagsIn,
                          QtTimeRecord_Convert, &movieTime))
        return NULL;
    _rv = MediaIdle(mh,
                    atMediaTime,
                    flagsIn,
                    &flagsOut,
                    &movieTime);
    _res = Py_BuildValue("ll",
                         _rv,
                         flagsOut);
    return _res;
}

static PyObject *Qt_MediaGetMediaInfo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Handle h;
#ifndef MediaGetMediaInfo
    PyMac_PRECHECK(MediaGetMediaInfo);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          ResObj_Convert, &h))
        return NULL;
    _rv = MediaGetMediaInfo(mh,
                            h);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaPutMediaInfo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Handle h;
#ifndef MediaPutMediaInfo
    PyMac_PRECHECK(MediaPutMediaInfo);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          ResObj_Convert, &h))
        return NULL;
    _rv = MediaPutMediaInfo(mh,
                            h);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSetActive(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Boolean enableMedia;
#ifndef MediaSetActive
    PyMac_PRECHECK(MediaSetActive);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          CmpInstObj_Convert, &mh,
                          &enableMedia))
        return NULL;
    _rv = MediaSetActive(mh,
                         enableMedia);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSetRate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Fixed rate;
#ifndef MediaSetRate
    PyMac_PRECHECK(MediaSetRate);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          PyMac_GetFixed, &rate))
        return NULL;
    _rv = MediaSetRate(mh,
                       rate);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGGetStatus(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    ComponentResult statusErr;
#ifndef MediaGGetStatus
    PyMac_PRECHECK(MediaGGetStatus);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGGetStatus(mh,
                          &statusErr);
    _res = Py_BuildValue("ll",
                         _rv,
                         statusErr);
    return _res;
}

static PyObject *Qt_MediaTrackEdited(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
#ifndef MediaTrackEdited
    PyMac_PRECHECK(MediaTrackEdited);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaTrackEdited(mh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSetMediaTimeScale(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    TimeScale newTimeScale;
#ifndef MediaSetMediaTimeScale
    PyMac_PRECHECK(MediaSetMediaTimeScale);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &newTimeScale))
        return NULL;
    _rv = MediaSetMediaTimeScale(mh,
                                 newTimeScale);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSetMovieTimeScale(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    TimeScale newTimeScale;
#ifndef MediaSetMovieTimeScale
    PyMac_PRECHECK(MediaSetMovieTimeScale);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &newTimeScale))
        return NULL;
    _rv = MediaSetMovieTimeScale(mh,
                                 newTimeScale);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSetGWorld(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    CGrafPtr aPort;
    GDHandle aGD;
#ifndef MediaSetGWorld
    PyMac_PRECHECK(MediaSetGWorld);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &mh,
                          GrafObj_Convert, &aPort,
                          OptResObj_Convert, &aGD))
        return NULL;
    _rv = MediaSetGWorld(mh,
                         aPort,
                         aGD);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSetDimensions(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Fixed width;
    Fixed height;
#ifndef MediaSetDimensions
    PyMac_PRECHECK(MediaSetDimensions);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &mh,
                          PyMac_GetFixed, &width,
                          PyMac_GetFixed, &height))
        return NULL;
    _rv = MediaSetDimensions(mh,
                             width,
                             height);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSetClip(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    RgnHandle theClip;
#ifndef MediaSetClip
    PyMac_PRECHECK(MediaSetClip);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          ResObj_Convert, &theClip))
        return NULL;
    _rv = MediaSetClip(mh,
                       theClip);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetTrackOpaque(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Boolean trackIsOpaque;
#ifndef MediaGetTrackOpaque
    PyMac_PRECHECK(MediaGetTrackOpaque);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetTrackOpaque(mh,
                              &trackIsOpaque);
    _res = Py_BuildValue("lb",
                         _rv,
                         trackIsOpaque);
    return _res;
}

static PyObject *Qt_MediaSetGraphicsMode(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long mode;
    RGBColor opColor;
#ifndef MediaSetGraphicsMode
    PyMac_PRECHECK(MediaSetGraphicsMode);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          CmpInstObj_Convert, &mh,
                          &mode,
                          QdRGB_Convert, &opColor))
        return NULL;
    _rv = MediaSetGraphicsMode(mh,
                               mode,
                               &opColor);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetGraphicsMode(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long mode;
    RGBColor opColor;
#ifndef MediaGetGraphicsMode
    PyMac_PRECHECK(MediaGetGraphicsMode);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetGraphicsMode(mh,
                               &mode,
                               &opColor);
    _res = Py_BuildValue("llO&",
                         _rv,
                         mode,
                         QdRGB_New, &opColor);
    return _res;
}

static PyObject *Qt_MediaGSetVolume(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short volume;
#ifndef MediaGSetVolume
    PyMac_PRECHECK(MediaGSetVolume);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &mh,
                          &volume))
        return NULL;
    _rv = MediaGSetVolume(mh,
                          volume);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSetSoundBalance(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short balance;
#ifndef MediaSetSoundBalance
    PyMac_PRECHECK(MediaSetSoundBalance);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &mh,
                          &balance))
        return NULL;
    _rv = MediaSetSoundBalance(mh,
                               balance);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetSoundBalance(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short balance;
#ifndef MediaGetSoundBalance
    PyMac_PRECHECK(MediaGetSoundBalance);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetSoundBalance(mh,
                               &balance);
    _res = Py_BuildValue("lh",
                         _rv,
                         balance);
    return _res;
}

static PyObject *Qt_MediaGetNextBoundsChange(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    TimeValue when;
#ifndef MediaGetNextBoundsChange
    PyMac_PRECHECK(MediaGetNextBoundsChange);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetNextBoundsChange(mh,
                                   &when);
    _res = Py_BuildValue("ll",
                         _rv,
                         when);
    return _res;
}

static PyObject *Qt_MediaGetSrcRgn(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    RgnHandle rgn;
    TimeValue atMediaTime;
#ifndef MediaGetSrcRgn
    PyMac_PRECHECK(MediaGetSrcRgn);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          CmpInstObj_Convert, &mh,
                          ResObj_Convert, &rgn,
                          &atMediaTime))
        return NULL;
    _rv = MediaGetSrcRgn(mh,
                         rgn,
                         atMediaTime);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaPreroll(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    TimeValue time;
    Fixed rate;
#ifndef MediaPreroll
    PyMac_PRECHECK(MediaPreroll);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          CmpInstObj_Convert, &mh,
                          &time,
                          PyMac_GetFixed, &rate))
        return NULL;
    _rv = MediaPreroll(mh,
                       time,
                       rate);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSampleDescriptionChanged(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long index;
#ifndef MediaSampleDescriptionChanged
    PyMac_PRECHECK(MediaSampleDescriptionChanged);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &index))
        return NULL;
    _rv = MediaSampleDescriptionChanged(mh,
                                        index);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaHasCharacteristic(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    OSType characteristic;
    Boolean hasIt;
#ifndef MediaHasCharacteristic
    PyMac_PRECHECK(MediaHasCharacteristic);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          PyMac_GetOSType, &characteristic))
        return NULL;
    _rv = MediaHasCharacteristic(mh,
                                 characteristic,
                                 &hasIt);
    _res = Py_BuildValue("lb",
                         _rv,
                         hasIt);
    return _res;
}

static PyObject *Qt_MediaGetOffscreenBufferSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Rect bounds;
    short depth;
    CTabHandle ctab;
#ifndef MediaGetOffscreenBufferSize
    PyMac_PRECHECK(MediaGetOffscreenBufferSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&hO&",
                          CmpInstObj_Convert, &mh,
                          &depth,
                          ResObj_Convert, &ctab))
        return NULL;
    _rv = MediaGetOffscreenBufferSize(mh,
                                      &bounds,
                                      depth,
                                      ctab);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &bounds);
    return _res;
}

static PyObject *Qt_MediaSetHints(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long hints;
#ifndef MediaSetHints
    PyMac_PRECHECK(MediaSetHints);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &hints))
        return NULL;
    _rv = MediaSetHints(mh,
                        hints);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetName(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Str255 name;
    long requestedLanguage;
    long actualLanguage;
#ifndef MediaGetName
    PyMac_PRECHECK(MediaGetName);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          CmpInstObj_Convert, &mh,
                          PyMac_GetStr255, name,
                          &requestedLanguage))
        return NULL;
    _rv = MediaGetName(mh,
                       name,
                       requestedLanguage,
                       &actualLanguage);
    _res = Py_BuildValue("ll",
                         _rv,
                         actualLanguage);
    return _res;
}

static PyObject *Qt_MediaForceUpdate(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long forceUpdateFlags;
#ifndef MediaForceUpdate
    PyMac_PRECHECK(MediaForceUpdate);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &forceUpdateFlags))
        return NULL;
    _rv = MediaForceUpdate(mh,
                           forceUpdateFlags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetDrawingRgn(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    RgnHandle partialRgn;
#ifndef MediaGetDrawingRgn
    PyMac_PRECHECK(MediaGetDrawingRgn);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetDrawingRgn(mh,
                             &partialRgn);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, partialRgn);
    return _res;
}

static PyObject *Qt_MediaGSetActiveSegment(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    TimeValue activeStart;
    TimeValue activeDuration;
#ifndef MediaGSetActiveSegment
    PyMac_PRECHECK(MediaGSetActiveSegment);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mh,
                          &activeStart,
                          &activeDuration))
        return NULL;
    _rv = MediaGSetActiveSegment(mh,
                                 activeStart,
                                 activeDuration);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaInvalidateRegion(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    RgnHandle invalRgn;
#ifndef MediaInvalidateRegion
    PyMac_PRECHECK(MediaInvalidateRegion);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          ResObj_Convert, &invalRgn))
        return NULL;
    _rv = MediaInvalidateRegion(mh,
                                invalRgn);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetNextStepTime(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short flags;
    TimeValue mediaTimeIn;
    TimeValue mediaTimeOut;
    Fixed rate;
#ifndef MediaGetNextStepTime
    PyMac_PRECHECK(MediaGetNextStepTime);
#endif
    if (!PyArg_ParseTuple(_args, "O&hlO&",
                          CmpInstObj_Convert, &mh,
                          &flags,
                          &mediaTimeIn,
                          PyMac_GetFixed, &rate))
        return NULL;
    _rv = MediaGetNextStepTime(mh,
                               flags,
                               mediaTimeIn,
                               &mediaTimeOut,
                               rate);
    _res = Py_BuildValue("ll",
                         _rv,
                         mediaTimeOut);
    return _res;
}

static PyObject *Qt_MediaChangedNonPrimarySource(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long inputIndex;
#ifndef MediaChangedNonPrimarySource
    PyMac_PRECHECK(MediaChangedNonPrimarySource);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &inputIndex))
        return NULL;
    _rv = MediaChangedNonPrimarySource(mh,
                                       inputIndex);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaTrackReferencesChanged(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
#ifndef MediaTrackReferencesChanged
    PyMac_PRECHECK(MediaTrackReferencesChanged);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaTrackReferencesChanged(mh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaReleaseSampleDataPointer(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long sampleNum;
#ifndef MediaReleaseSampleDataPointer
    PyMac_PRECHECK(MediaReleaseSampleDataPointer);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &sampleNum))
        return NULL;
    _rv = MediaReleaseSampleDataPointer(mh,
                                        sampleNum);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaTrackPropertyAtomChanged(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
#ifndef MediaTrackPropertyAtomChanged
    PyMac_PRECHECK(MediaTrackPropertyAtomChanged);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaTrackPropertyAtomChanged(mh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSetVideoParam(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long whichParam;
    unsigned short value;
#ifndef MediaSetVideoParam
    PyMac_PRECHECK(MediaSetVideoParam);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &whichParam))
        return NULL;
    _rv = MediaSetVideoParam(mh,
                             whichParam,
                             &value);
    _res = Py_BuildValue("lH",
                         _rv,
                         value);
    return _res;
}

static PyObject *Qt_MediaGetVideoParam(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long whichParam;
    unsigned short value;
#ifndef MediaGetVideoParam
    PyMac_PRECHECK(MediaGetVideoParam);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &whichParam))
        return NULL;
    _rv = MediaGetVideoParam(mh,
                             whichParam,
                             &value);
    _res = Py_BuildValue("lH",
                         _rv,
                         value);
    return _res;
}

static PyObject *Qt_MediaCompare(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Boolean isOK;
    Media srcMedia;
    ComponentInstance srcMediaComponent;
#ifndef MediaCompare
    PyMac_PRECHECK(MediaCompare);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          CmpInstObj_Convert, &mh,
                          MediaObj_Convert, &srcMedia,
                          CmpInstObj_Convert, &srcMediaComponent))
        return NULL;
    _rv = MediaCompare(mh,
                       &isOK,
                       srcMedia,
                       srcMediaComponent);
    _res = Py_BuildValue("lb",
                         _rv,
                         isOK);
    return _res;
}

static PyObject *Qt_MediaGetClock(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    ComponentInstance clock;
#ifndef MediaGetClock
    PyMac_PRECHECK(MediaGetClock);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetClock(mh,
                        &clock);
    _res = Py_BuildValue("lO&",
                         _rv,
                         CmpInstObj_New, clock);
    return _res;
}

static PyObject *Qt_MediaSetSoundOutputComponent(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Component outputComponent;
#ifndef MediaSetSoundOutputComponent
    PyMac_PRECHECK(MediaSetSoundOutputComponent);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          CmpObj_Convert, &outputComponent))
        return NULL;
    _rv = MediaSetSoundOutputComponent(mh,
                                       outputComponent);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetSoundOutputComponent(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Component outputComponent;
#ifndef MediaGetSoundOutputComponent
    PyMac_PRECHECK(MediaGetSoundOutputComponent);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetSoundOutputComponent(mh,
                                       &outputComponent);
    _res = Py_BuildValue("lO&",
                         _rv,
                         CmpObj_New, outputComponent);
    return _res;
}

static PyObject *Qt_MediaSetSoundLocalizationData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Handle data;
#ifndef MediaSetSoundLocalizationData
    PyMac_PRECHECK(MediaSetSoundLocalizationData);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          ResObj_Convert, &data))
        return NULL;
    _rv = MediaSetSoundLocalizationData(mh,
                                        data);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetInvalidRegion(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    RgnHandle rgn;
#ifndef MediaGetInvalidRegion
    PyMac_PRECHECK(MediaGetInvalidRegion);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          ResObj_Convert, &rgn))
        return NULL;
    _rv = MediaGetInvalidRegion(mh,
                                rgn);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSampleDescriptionB2N(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    SampleDescriptionHandle sampleDescriptionH;
#ifndef MediaSampleDescriptionB2N
    PyMac_PRECHECK(MediaSampleDescriptionB2N);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          ResObj_Convert, &sampleDescriptionH))
        return NULL;
    _rv = MediaSampleDescriptionB2N(mh,
                                    sampleDescriptionH);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSampleDescriptionN2B(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    SampleDescriptionHandle sampleDescriptionH;
#ifndef MediaSampleDescriptionN2B
    PyMac_PRECHECK(MediaSampleDescriptionN2B);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          ResObj_Convert, &sampleDescriptionH))
        return NULL;
    _rv = MediaSampleDescriptionN2B(mh,
                                    sampleDescriptionH);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaFlushNonPrimarySourceData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long inputIndex;
#ifndef MediaFlushNonPrimarySourceData
    PyMac_PRECHECK(MediaFlushNonPrimarySourceData);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &inputIndex))
        return NULL;
    _rv = MediaFlushNonPrimarySourceData(mh,
                                         inputIndex);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetURLLink(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Point displayWhere;
    Handle urlLink;
#ifndef MediaGetURLLink
    PyMac_PRECHECK(MediaGetURLLink);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          PyMac_GetPoint, &displayWhere))
        return NULL;
    _rv = MediaGetURLLink(mh,
                          displayWhere,
                          &urlLink);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, urlLink);
    return _res;
}

static PyObject *Qt_MediaHitTestForTargetRefCon(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long flags;
    Point loc;
    long targetRefCon;
#ifndef MediaHitTestForTargetRefCon
    PyMac_PRECHECK(MediaHitTestForTargetRefCon);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          CmpInstObj_Convert, &mh,
                          &flags,
                          PyMac_GetPoint, &loc))
        return NULL;
    _rv = MediaHitTestForTargetRefCon(mh,
                                      flags,
                                      loc,
                                      &targetRefCon);
    _res = Py_BuildValue("ll",
                         _rv,
                         targetRefCon);
    return _res;
}

static PyObject *Qt_MediaHitTestTargetRefCon(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long targetRefCon;
    long flags;
    Point loc;
    Boolean wasHit;
#ifndef MediaHitTestTargetRefCon
    PyMac_PRECHECK(MediaHitTestTargetRefCon);
#endif
    if (!PyArg_ParseTuple(_args, "O&llO&",
                          CmpInstObj_Convert, &mh,
                          &targetRefCon,
                          &flags,
                          PyMac_GetPoint, &loc))
        return NULL;
    _rv = MediaHitTestTargetRefCon(mh,
                                   targetRefCon,
                                   flags,
                                   loc,
                                   &wasHit);
    _res = Py_BuildValue("lb",
                         _rv,
                         wasHit);
    return _res;
}

static PyObject *Qt_MediaDisposeTargetRefCon(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long targetRefCon;
#ifndef MediaDisposeTargetRefCon
    PyMac_PRECHECK(MediaDisposeTargetRefCon);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &targetRefCon))
        return NULL;
    _rv = MediaDisposeTargetRefCon(mh,
                                   targetRefCon);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaTargetRefConsEqual(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long firstRefCon;
    long secondRefCon;
    Boolean equal;
#ifndef MediaTargetRefConsEqual
    PyMac_PRECHECK(MediaTargetRefConsEqual);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mh,
                          &firstRefCon,
                          &secondRefCon))
        return NULL;
    _rv = MediaTargetRefConsEqual(mh,
                                  firstRefCon,
                                  secondRefCon,
                                  &equal);
    _res = Py_BuildValue("lb",
                         _rv,
                         equal);
    return _res;
}

static PyObject *Qt_MediaPrePrerollCancel(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    void * refcon;
#ifndef MediaPrePrerollCancel
    PyMac_PRECHECK(MediaPrePrerollCancel);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &mh,
                          &refcon))
        return NULL;
    _rv = MediaPrePrerollCancel(mh,
                                refcon);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaEnterEmptyEdit(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
#ifndef MediaEnterEmptyEdit
    PyMac_PRECHECK(MediaEnterEmptyEdit);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaEnterEmptyEdit(mh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaCurrentMediaQueuedData(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long milliSecs;
#ifndef MediaCurrentMediaQueuedData
    PyMac_PRECHECK(MediaCurrentMediaQueuedData);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaCurrentMediaQueuedData(mh,
                                      &milliSecs);
    _res = Py_BuildValue("ll",
                         _rv,
                         milliSecs);
    return _res;
}

static PyObject *Qt_MediaGetEffectiveVolume(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short volume;
#ifndef MediaGetEffectiveVolume
    PyMac_PRECHECK(MediaGetEffectiveVolume);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetEffectiveVolume(mh,
                                  &volume);
    _res = Py_BuildValue("lh",
                         _rv,
                         volume);
    return _res;
}

static PyObject *Qt_MediaGetSoundLevelMeteringEnabled(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Boolean enabled;
#ifndef MediaGetSoundLevelMeteringEnabled
    PyMac_PRECHECK(MediaGetSoundLevelMeteringEnabled);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetSoundLevelMeteringEnabled(mh,
                                            &enabled);
    _res = Py_BuildValue("lb",
                         _rv,
                         enabled);
    return _res;
}

static PyObject *Qt_MediaSetSoundLevelMeteringEnabled(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Boolean enable;
#ifndef MediaSetSoundLevelMeteringEnabled
    PyMac_PRECHECK(MediaSetSoundLevelMeteringEnabled);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          CmpInstObj_Convert, &mh,
                          &enable))
        return NULL;
    _rv = MediaSetSoundLevelMeteringEnabled(mh,
                                            enable);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetEffectiveSoundBalance(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short balance;
#ifndef MediaGetEffectiveSoundBalance
    PyMac_PRECHECK(MediaGetEffectiveSoundBalance);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetEffectiveSoundBalance(mh,
                                        &balance);
    _res = Py_BuildValue("lh",
                         _rv,
                         balance);
    return _res;
}

static PyObject *Qt_MediaSetScreenLock(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Boolean lockIt;
#ifndef MediaSetScreenLock
    PyMac_PRECHECK(MediaSetScreenLock);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          CmpInstObj_Convert, &mh,
                          &lockIt))
        return NULL;
    _rv = MediaSetScreenLock(mh,
                             lockIt);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetErrorString(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    ComponentResult theError;
    Str255 errorString;
#ifndef MediaGetErrorString
    PyMac_PRECHECK(MediaGetErrorString);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          CmpInstObj_Convert, &mh,
                          &theError,
                          PyMac_GetStr255, errorString))
        return NULL;
    _rv = MediaGetErrorString(mh,
                              theError,
                              errorString);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetSoundEqualizerBandLevels(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    UInt8 bandLevels;
#ifndef MediaGetSoundEqualizerBandLevels
    PyMac_PRECHECK(MediaGetSoundEqualizerBandLevels);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetSoundEqualizerBandLevels(mh,
                                           &bandLevels);
    _res = Py_BuildValue("lb",
                         _rv,
                         bandLevels);
    return _res;
}

static PyObject *Qt_MediaDoIdleActions(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
#ifndef MediaDoIdleActions
    PyMac_PRECHECK(MediaDoIdleActions);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaDoIdleActions(mh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaSetSoundBassAndTreble(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short bass;
    short treble;
#ifndef MediaSetSoundBassAndTreble
    PyMac_PRECHECK(MediaSetSoundBassAndTreble);
#endif
    if (!PyArg_ParseTuple(_args, "O&hh",
                          CmpInstObj_Convert, &mh,
                          &bass,
                          &treble))
        return NULL;
    _rv = MediaSetSoundBassAndTreble(mh,
                                     bass,
                                     treble);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetSoundBassAndTreble(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    short bass;
    short treble;
#ifndef MediaGetSoundBassAndTreble
    PyMac_PRECHECK(MediaGetSoundBassAndTreble);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetSoundBassAndTreble(mh,
                                     &bass,
                                     &treble);
    _res = Py_BuildValue("lhh",
                         _rv,
                         bass,
                         treble);
    return _res;
}

static PyObject *Qt_MediaTimeBaseChanged(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
#ifndef MediaTimeBaseChanged
    PyMac_PRECHECK(MediaTimeBaseChanged);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaTimeBaseChanged(mh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaMCIsPlayerEvent(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    EventRecord e;
    Boolean handledIt;
#ifndef MediaMCIsPlayerEvent
    PyMac_PRECHECK(MediaMCIsPlayerEvent);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          PyMac_GetEventRecord, &e))
        return NULL;
    _rv = MediaMCIsPlayerEvent(mh,
                               &e,
                               &handledIt);
    _res = Py_BuildValue("lb",
                         _rv,
                         handledIt);
    return _res;
}

static PyObject *Qt_MediaGetMediaLoadState(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long mediaLoadState;
#ifndef MediaGetMediaLoadState
    PyMac_PRECHECK(MediaGetMediaLoadState);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGetMediaLoadState(mh,
                                 &mediaLoadState);
    _res = Py_BuildValue("ll",
                         _rv,
                         mediaLoadState);
    return _res;
}

static PyObject *Qt_MediaVideoOutputChanged(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    ComponentInstance vout;
#ifndef MediaVideoOutputChanged
    PyMac_PRECHECK(MediaVideoOutputChanged);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          CmpInstObj_Convert, &vout))
        return NULL;
    _rv = MediaVideoOutputChanged(mh,
                                  vout);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaEmptySampleCache(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long sampleNum;
    long sampleCount;
#ifndef MediaEmptySampleCache
    PyMac_PRECHECK(MediaEmptySampleCache);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mh,
                          &sampleNum,
                          &sampleCount))
        return NULL;
    _rv = MediaEmptySampleCache(mh,
                                sampleNum,
                                sampleCount);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaGetPublicInfo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    OSType infoSelector;
    void * infoDataPtr;
    Size ioDataSize;
#ifndef MediaGetPublicInfo
    PyMac_PRECHECK(MediaGetPublicInfo);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&s",
                          CmpInstObj_Convert, &mh,
                          PyMac_GetOSType, &infoSelector,
                          &infoDataPtr))
        return NULL;
    _rv = MediaGetPublicInfo(mh,
                             infoSelector,
                             infoDataPtr,
                             &ioDataSize);
    _res = Py_BuildValue("ll",
                         _rv,
                         ioDataSize);
    return _res;
}

static PyObject *Qt_MediaSetPublicInfo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    OSType infoSelector;
    void * infoDataPtr;
    Size dataSize;
#ifndef MediaSetPublicInfo
    PyMac_PRECHECK(MediaSetPublicInfo);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&sl",
                          CmpInstObj_Convert, &mh,
                          PyMac_GetOSType, &infoSelector,
                          &infoDataPtr,
                          &dataSize))
        return NULL;
    _rv = MediaSetPublicInfo(mh,
                             infoSelector,
                             infoDataPtr,
                             dataSize);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaRefConSetProperty(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long refCon;
    long propertyType;
    void * propertyValue;
#ifndef MediaRefConSetProperty
    PyMac_PRECHECK(MediaRefConSetProperty);
#endif
    if (!PyArg_ParseTuple(_args, "O&lls",
                          CmpInstObj_Convert, &mh,
                          &refCon,
                          &propertyType,
                          &propertyValue))
        return NULL;
    _rv = MediaRefConSetProperty(mh,
                                 refCon,
                                 propertyType,
                                 propertyValue);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaRefConGetProperty(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long refCon;
    long propertyType;
    void * propertyValue;
#ifndef MediaRefConGetProperty
    PyMac_PRECHECK(MediaRefConGetProperty);
#endif
    if (!PyArg_ParseTuple(_args, "O&lls",
                          CmpInstObj_Convert, &mh,
                          &refCon,
                          &propertyType,
                          &propertyValue))
        return NULL;
    _rv = MediaRefConGetProperty(mh,
                                 refCon,
                                 propertyType,
                                 propertyValue);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MediaNavigateTargetRefCon(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    long navigation;
    long refCon;
#ifndef MediaNavigateTargetRefCon
    PyMac_PRECHECK(MediaNavigateTargetRefCon);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mh,
                          &navigation))
        return NULL;
    _rv = MediaNavigateTargetRefCon(mh,
                                    navigation,
                                    &refCon);
    _res = Py_BuildValue("ll",
                         _rv,
                         refCon);
    return _res;
}

static PyObject *Qt_MediaGGetIdleManager(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    IdleManager pim;
#ifndef MediaGGetIdleManager
    PyMac_PRECHECK(MediaGGetIdleManager);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = MediaGGetIdleManager(mh,
                               &pim);
    _res = Py_BuildValue("lO&",
                         _rv,
                         IdleManagerObj_New, pim);
    return _res;
}

static PyObject *Qt_MediaGSetIdleManager(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    IdleManager im;
#ifndef MediaGSetIdleManager
    PyMac_PRECHECK(MediaGSetIdleManager);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mh,
                          IdleManagerObj_Convert, &im))
        return NULL;
    _rv = MediaGSetIdleManager(mh,
                               im);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_QTMIDIGetMIDIPorts(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTMIDIComponent ci;
    QTMIDIPortListHandle inputPorts;
    QTMIDIPortListHandle outputPorts;
#ifndef QTMIDIGetMIDIPorts
    PyMac_PRECHECK(QTMIDIGetMIDIPorts);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &ci))
        return NULL;
    _rv = QTMIDIGetMIDIPorts(ci,
                             &inputPorts,
                             &outputPorts);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, inputPorts,
                         ResObj_New, outputPorts);
    return _res;
}

static PyObject *Qt_QTMIDIUseSendPort(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTMIDIComponent ci;
    long portIndex;
    long inUse;
#ifndef QTMIDIUseSendPort
    PyMac_PRECHECK(QTMIDIUseSendPort);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &ci,
                          &portIndex,
                          &inUse))
        return NULL;
    _rv = QTMIDIUseSendPort(ci,
                            portIndex,
                            inUse);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_QTMIDISendMIDI(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    QTMIDIComponent ci;
    long portIndex;
    MusicMIDIPacket mp;
#ifndef QTMIDISendMIDI
    PyMac_PRECHECK(QTMIDISendMIDI);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          CmpInstObj_Convert, &ci,
                          &portIndex,
                          QtMusicMIDIPacket_Convert, &mp))
        return NULL;
    _rv = QTMIDISendMIDI(ci,
                         portIndex,
                         &mp);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicGetPart(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    long midiChannel;
    long polyphony;
#ifndef MusicGetPart
    PyMac_PRECHECK(MusicGetPart);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mc,
                          &part))
        return NULL;
    _rv = MusicGetPart(mc,
                       part,
                       &midiChannel,
                       &polyphony);
    _res = Py_BuildValue("lll",
                         _rv,
                         midiChannel,
                         polyphony);
    return _res;
}

static PyObject *Qt_MusicSetPart(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    long midiChannel;
    long polyphony;
#ifndef MusicSetPart
    PyMac_PRECHECK(MusicSetPart);
#endif
    if (!PyArg_ParseTuple(_args, "O&lll",
                          CmpInstObj_Convert, &mc,
                          &part,
                          &midiChannel,
                          &polyphony))
        return NULL;
    _rv = MusicSetPart(mc,
                       part,
                       midiChannel,
                       polyphony);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicSetPartInstrumentNumber(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    long instrumentNumber;
#ifndef MusicSetPartInstrumentNumber
    PyMac_PRECHECK(MusicSetPartInstrumentNumber);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mc,
                          &part,
                          &instrumentNumber))
        return NULL;
    _rv = MusicSetPartInstrumentNumber(mc,
                                       part,
                                       instrumentNumber);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicGetPartInstrumentNumber(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
#ifndef MusicGetPartInstrumentNumber
    PyMac_PRECHECK(MusicGetPartInstrumentNumber);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mc,
                          &part))
        return NULL;
    _rv = MusicGetPartInstrumentNumber(mc,
                                       part);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicStorePartInstrument(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    long instrumentNumber;
#ifndef MusicStorePartInstrument
    PyMac_PRECHECK(MusicStorePartInstrument);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mc,
                          &part,
                          &instrumentNumber))
        return NULL;
    _rv = MusicStorePartInstrument(mc,
                                   part,
                                   instrumentNumber);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicGetPartAtomicInstrument(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    AtomicInstrument ai;
    long flags;
#ifndef MusicGetPartAtomicInstrument
    PyMac_PRECHECK(MusicGetPartAtomicInstrument);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mc,
                          &part,
                          &flags))
        return NULL;
    _rv = MusicGetPartAtomicInstrument(mc,
                                       part,
                                       &ai,
                                       flags);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, ai);
    return _res;
}

static PyObject *Qt_MusicSetPartAtomicInstrument(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    AtomicInstrumentPtr aiP;
    long flags;
#ifndef MusicSetPartAtomicInstrument
    PyMac_PRECHECK(MusicSetPartAtomicInstrument);
#endif
    if (!PyArg_ParseTuple(_args, "O&lsl",
                          CmpInstObj_Convert, &mc,
                          &part,
                          &aiP,
                          &flags))
        return NULL;
    _rv = MusicSetPartAtomicInstrument(mc,
                                       part,
                                       aiP,
                                       flags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicGetPartKnob(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    long knobID;
#ifndef MusicGetPartKnob
    PyMac_PRECHECK(MusicGetPartKnob);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mc,
                          &part,
                          &knobID))
        return NULL;
    _rv = MusicGetPartKnob(mc,
                           part,
                           knobID);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicSetPartKnob(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    long knobID;
    long knobValue;
#ifndef MusicSetPartKnob
    PyMac_PRECHECK(MusicSetPartKnob);
#endif
    if (!PyArg_ParseTuple(_args, "O&lll",
                          CmpInstObj_Convert, &mc,
                          &part,
                          &knobID,
                          &knobValue))
        return NULL;
    _rv = MusicSetPartKnob(mc,
                           part,
                           knobID,
                           knobValue);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicGetKnob(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long knobID;
#ifndef MusicGetKnob
    PyMac_PRECHECK(MusicGetKnob);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mc,
                          &knobID))
        return NULL;
    _rv = MusicGetKnob(mc,
                       knobID);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicSetKnob(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long knobID;
    long knobValue;
#ifndef MusicSetKnob
    PyMac_PRECHECK(MusicSetKnob);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mc,
                          &knobID,
                          &knobValue))
        return NULL;
    _rv = MusicSetKnob(mc,
                       knobID,
                       knobValue);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicGetPartName(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    StringPtr name;
#ifndef MusicGetPartName
    PyMac_PRECHECK(MusicGetPartName);
#endif
    if (!PyArg_ParseTuple(_args, "O&ls",
                          CmpInstObj_Convert, &mc,
                          &part,
                          &name))
        return NULL;
    _rv = MusicGetPartName(mc,
                           part,
                           name);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicSetPartName(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    StringPtr name;
#ifndef MusicSetPartName
    PyMac_PRECHECK(MusicSetPartName);
#endif
    if (!PyArg_ParseTuple(_args, "O&ls",
                          CmpInstObj_Convert, &mc,
                          &part,
                          &name))
        return NULL;
    _rv = MusicSetPartName(mc,
                           part,
                           name);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicPlayNote(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    long pitch;
    long velocity;
#ifndef MusicPlayNote
    PyMac_PRECHECK(MusicPlayNote);
#endif
    if (!PyArg_ParseTuple(_args, "O&lll",
                          CmpInstObj_Convert, &mc,
                          &part,
                          &pitch,
                          &velocity))
        return NULL;
    _rv = MusicPlayNote(mc,
                        part,
                        pitch,
                        velocity);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicResetPart(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
#ifndef MusicResetPart
    PyMac_PRECHECK(MusicResetPart);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mc,
                          &part))
        return NULL;
    _rv = MusicResetPart(mc,
                         part);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicSetPartController(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    MusicController controllerNumber;
    long controllerValue;
#ifndef MusicSetPartController
    PyMac_PRECHECK(MusicSetPartController);
#endif
    if (!PyArg_ParseTuple(_args, "O&lll",
                          CmpInstObj_Convert, &mc,
                          &part,
                          &controllerNumber,
                          &controllerValue))
        return NULL;
    _rv = MusicSetPartController(mc,
                                 part,
                                 controllerNumber,
                                 controllerValue);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicGetPartController(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    MusicController controllerNumber;
#ifndef MusicGetPartController
    PyMac_PRECHECK(MusicGetPartController);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mc,
                          &part,
                          &controllerNumber))
        return NULL;
    _rv = MusicGetPartController(mc,
                                 part,
                                 controllerNumber);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicGetInstrumentNames(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long modifiableInstruments;
    Handle instrumentNames;
    Handle instrumentCategoryLasts;
    Handle instrumentCategoryNames;
#ifndef MusicGetInstrumentNames
    PyMac_PRECHECK(MusicGetInstrumentNames);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mc,
                          &modifiableInstruments))
        return NULL;
    _rv = MusicGetInstrumentNames(mc,
                                  modifiableInstruments,
                                  &instrumentNames,
                                  &instrumentCategoryLasts,
                                  &instrumentCategoryNames);
    _res = Py_BuildValue("lO&O&O&",
                         _rv,
                         ResObj_New, instrumentNames,
                         ResObj_New, instrumentCategoryLasts,
                         ResObj_New, instrumentCategoryNames);
    return _res;
}

static PyObject *Qt_MusicGetDrumNames(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long modifiableInstruments;
    Handle instrumentNumbers;
    Handle instrumentNames;
#ifndef MusicGetDrumNames
    PyMac_PRECHECK(MusicGetDrumNames);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mc,
                          &modifiableInstruments))
        return NULL;
    _rv = MusicGetDrumNames(mc,
                            modifiableInstruments,
                            &instrumentNumbers,
                            &instrumentNames);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, instrumentNumbers,
                         ResObj_New, instrumentNames);
    return _res;
}

static PyObject *Qt_MusicGetMasterTune(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
#ifndef MusicGetMasterTune
    PyMac_PRECHECK(MusicGetMasterTune);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mc))
        return NULL;
    _rv = MusicGetMasterTune(mc);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicSetMasterTune(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long masterTune;
#ifndef MusicSetMasterTune
    PyMac_PRECHECK(MusicSetMasterTune);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mc,
                          &masterTune))
        return NULL;
    _rv = MusicSetMasterTune(mc,
                             masterTune);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicGetDeviceConnection(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long index;
    long id1;
    long id2;
#ifndef MusicGetDeviceConnection
    PyMac_PRECHECK(MusicGetDeviceConnection);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mc,
                          &index))
        return NULL;
    _rv = MusicGetDeviceConnection(mc,
                                   index,
                                   &id1,
                                   &id2);
    _res = Py_BuildValue("lll",
                         _rv,
                         id1,
                         id2);
    return _res;
}

static PyObject *Qt_MusicUseDeviceConnection(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long id1;
    long id2;
#ifndef MusicUseDeviceConnection
    PyMac_PRECHECK(MusicUseDeviceConnection);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mc,
                          &id1,
                          &id2))
        return NULL;
    _rv = MusicUseDeviceConnection(mc,
                                   id1,
                                   id2);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicGetKnobSettingStrings(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long knobIndex;
    long isGlobal;
    Handle settingsNames;
    Handle settingsCategoryLasts;
    Handle settingsCategoryNames;
#ifndef MusicGetKnobSettingStrings
    PyMac_PRECHECK(MusicGetKnobSettingStrings);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mc,
                          &knobIndex,
                          &isGlobal))
        return NULL;
    _rv = MusicGetKnobSettingStrings(mc,
                                     knobIndex,
                                     isGlobal,
                                     &settingsNames,
                                     &settingsCategoryLasts,
                                     &settingsCategoryNames);
    _res = Py_BuildValue("lO&O&O&",
                         _rv,
                         ResObj_New, settingsNames,
                         ResObj_New, settingsCategoryLasts,
                         ResObj_New, settingsCategoryNames);
    return _res;
}

static PyObject *Qt_MusicGetMIDIPorts(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long inputPortCount;
    long outputPortCount;
#ifndef MusicGetMIDIPorts
    PyMac_PRECHECK(MusicGetMIDIPorts);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mc))
        return NULL;
    _rv = MusicGetMIDIPorts(mc,
                            &inputPortCount,
                            &outputPortCount);
    _res = Py_BuildValue("lll",
                         _rv,
                         inputPortCount,
                         outputPortCount);
    return _res;
}

static PyObject *Qt_MusicSendMIDI(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long portIndex;
    MusicMIDIPacket mp;
#ifndef MusicSendMIDI
    PyMac_PRECHECK(MusicSendMIDI);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          CmpInstObj_Convert, &mc,
                          &portIndex,
                          QtMusicMIDIPacket_Convert, &mp))
        return NULL;
    _rv = MusicSendMIDI(mc,
                        portIndex,
                        &mp);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicSetOfflineTimeTo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long newTimeStamp;
#ifndef MusicSetOfflineTimeTo
    PyMac_PRECHECK(MusicSetOfflineTimeTo);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mc,
                          &newTimeStamp))
        return NULL;
    _rv = MusicSetOfflineTimeTo(mc,
                                newTimeStamp);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicGetInfoText(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long selector;
    Handle textH;
    Handle styleH;
#ifndef MusicGetInfoText
    PyMac_PRECHECK(MusicGetInfoText);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mc,
                          &selector))
        return NULL;
    _rv = MusicGetInfoText(mc,
                           selector,
                           &textH,
                           &styleH);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, textH,
                         ResObj_New, styleH);
    return _res;
}

static PyObject *Qt_MusicGetInstrumentInfo(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long getInstrumentInfoFlags;
    InstrumentInfoListHandle infoListH;
#ifndef MusicGetInstrumentInfo
    PyMac_PRECHECK(MusicGetInstrumentInfo);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mc,
                          &getInstrumentInfoFlags))
        return NULL;
    _rv = MusicGetInstrumentInfo(mc,
                                 getInstrumentInfoFlags,
                                 &infoListH);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, infoListH);
    return _res;
}

static PyObject *Qt_MusicTask(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
#ifndef MusicTask
    PyMac_PRECHECK(MusicTask);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mc))
        return NULL;
    _rv = MusicTask(mc);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicSetPartInstrumentNumberInterruptSafe(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    long instrumentNumber;
#ifndef MusicSetPartInstrumentNumberInterruptSafe
    PyMac_PRECHECK(MusicSetPartInstrumentNumberInterruptSafe);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CmpInstObj_Convert, &mc,
                          &part,
                          &instrumentNumber))
        return NULL;
    _rv = MusicSetPartInstrumentNumberInterruptSafe(mc,
                                                    part,
                                                    instrumentNumber);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicSetPartSoundLocalization(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long part;
    Handle data;
#ifndef MusicSetPartSoundLocalization
    PyMac_PRECHECK(MusicSetPartSoundLocalization);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          CmpInstObj_Convert, &mc,
                          &part,
                          ResObj_Convert, &data))
        return NULL;
    _rv = MusicSetPartSoundLocalization(mc,
                                        part,
                                        data);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicGenericConfigure(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long mode;
    long flags;
    long baseResID;
#ifndef MusicGenericConfigure
    PyMac_PRECHECK(MusicGenericConfigure);
#endif
    if (!PyArg_ParseTuple(_args, "O&lll",
                          CmpInstObj_Convert, &mc,
                          &mode,
                          &flags,
                          &baseResID))
        return NULL;
    _rv = MusicGenericConfigure(mc,
                                mode,
                                flags,
                                baseResID);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicGenericGetKnobList(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    long knobType;
    GenericKnobDescriptionListHandle gkdlH;
#ifndef MusicGenericGetKnobList
    PyMac_PRECHECK(MusicGenericGetKnobList);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &mc,
                          &knobType))
        return NULL;
    _rv = MusicGenericGetKnobList(mc,
                                  knobType,
                                  &gkdlH);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, gkdlH);
    return _res;
}

static PyObject *Qt_MusicGenericSetResourceNumbers(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    Handle resourceIDH;
#ifndef MusicGenericSetResourceNumbers
    PyMac_PRECHECK(MusicGenericSetResourceNumbers);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mc,
                          ResObj_Convert, &resourceIDH))
        return NULL;
    _rv = MusicGenericSetResourceNumbers(mc,
                                         resourceIDH);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicDerivedMIDISend(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    MusicMIDIPacket packet;
#ifndef MusicDerivedMIDISend
    PyMac_PRECHECK(MusicDerivedMIDISend);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &mc,
                          QtMusicMIDIPacket_Convert, &packet))
        return NULL;
    _rv = MusicDerivedMIDISend(mc,
                               &packet);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicDerivedOpenResFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
#ifndef MusicDerivedOpenResFile
    PyMac_PRECHECK(MusicDerivedOpenResFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mc))
        return NULL;
    _rv = MusicDerivedOpenResFile(mc);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_MusicDerivedCloseResFile(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MusicComponent mc;
    short resRefNum;
#ifndef MusicDerivedCloseResFile
    PyMac_PRECHECK(MusicDerivedCloseResFile);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &mc,
                          &resRefNum))
        return NULL;
    _rv = MusicDerivedCloseResFile(mc,
                                   resRefNum);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_NAUnregisterMusicDevice(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    NoteAllocator na;
    long index;
#ifndef NAUnregisterMusicDevice
    PyMac_PRECHECK(NAUnregisterMusicDevice);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &na,
                          &index))
        return NULL;
    _rv = NAUnregisterMusicDevice(na,
                                  index);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_NASaveMusicConfiguration(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    NoteAllocator na;
#ifndef NASaveMusicConfiguration
    PyMac_PRECHECK(NASaveMusicConfiguration);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &na))
        return NULL;
    _rv = NASaveMusicConfiguration(na);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_NAGetMIDIPorts(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    NoteAllocator na;
    QTMIDIPortListHandle inputPorts;
    QTMIDIPortListHandle outputPorts;
#ifndef NAGetMIDIPorts
    PyMac_PRECHECK(NAGetMIDIPorts);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &na))
        return NULL;
    _rv = NAGetMIDIPorts(na,
                         &inputPorts,
                         &outputPorts);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, inputPorts,
                         ResObj_New, outputPorts);
    return _res;
}

static PyObject *Qt_NATask(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    NoteAllocator na;
#ifndef NATask
    PyMac_PRECHECK(NATask);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &na))
        return NULL;
    _rv = NATask(na);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TuneSetHeader(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
    unsigned long * header;
#ifndef TuneSetHeader
    PyMac_PRECHECK(TuneSetHeader);
#endif
    if (!PyArg_ParseTuple(_args, "O&s",
                          CmpInstObj_Convert, &tp,
                          &header))
        return NULL;
    _rv = TuneSetHeader(tp,
                        header);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TuneGetTimeBase(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
    TimeBase tb;
#ifndef TuneGetTimeBase
    PyMac_PRECHECK(TuneGetTimeBase);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &tp))
        return NULL;
    _rv = TuneGetTimeBase(tp,
                          &tb);
    _res = Py_BuildValue("lO&",
                         _rv,
                         TimeBaseObj_New, tb);
    return _res;
}

static PyObject *Qt_TuneSetTimeScale(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
    TimeScale scale;
#ifndef TuneSetTimeScale
    PyMac_PRECHECK(TuneSetTimeScale);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &tp,
                          &scale))
        return NULL;
    _rv = TuneSetTimeScale(tp,
                           scale);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TuneGetTimeScale(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
    TimeScale scale;
#ifndef TuneGetTimeScale
    PyMac_PRECHECK(TuneGetTimeScale);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &tp))
        return NULL;
    _rv = TuneGetTimeScale(tp,
                           &scale);
    _res = Py_BuildValue("ll",
                         _rv,
                         scale);
    return _res;
}

static PyObject *Qt_TuneInstant(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
    unsigned long tune;
    unsigned long tunePosition;
#ifndef TuneInstant
    PyMac_PRECHECK(TuneInstant);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &tp,
                          &tunePosition))
        return NULL;
    _rv = TuneInstant(tp,
                      &tune,
                      tunePosition);
    _res = Py_BuildValue("ll",
                         _rv,
                         tune);
    return _res;
}

static PyObject *Qt_TuneStop(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
    long stopFlags;
#ifndef TuneStop
    PyMac_PRECHECK(TuneStop);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &tp,
                          &stopFlags))
        return NULL;
    _rv = TuneStop(tp,
                   stopFlags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TuneSetVolume(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
    Fixed volume;
#ifndef TuneSetVolume
    PyMac_PRECHECK(TuneSetVolume);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &tp,
                          PyMac_GetFixed, &volume))
        return NULL;
    _rv = TuneSetVolume(tp,
                        volume);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TuneGetVolume(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
#ifndef TuneGetVolume
    PyMac_PRECHECK(TuneGetVolume);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &tp))
        return NULL;
    _rv = TuneGetVolume(tp);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TunePreroll(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
#ifndef TunePreroll
    PyMac_PRECHECK(TunePreroll);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &tp))
        return NULL;
    _rv = TunePreroll(tp);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TuneUnroll(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
#ifndef TuneUnroll
    PyMac_PRECHECK(TuneUnroll);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &tp))
        return NULL;
    _rv = TuneUnroll(tp);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TuneSetPartTranspose(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
    unsigned long part;
    long transpose;
    long velocityShift;
#ifndef TuneSetPartTranspose
    PyMac_PRECHECK(TuneSetPartTranspose);
#endif
    if (!PyArg_ParseTuple(_args, "O&lll",
                          CmpInstObj_Convert, &tp,
                          &part,
                          &transpose,
                          &velocityShift))
        return NULL;
    _rv = TuneSetPartTranspose(tp,
                               part,
                               transpose,
                               velocityShift);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TuneGetNoteAllocator(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    NoteAllocator _rv;
    TunePlayer tp;
#ifndef TuneGetNoteAllocator
    PyMac_PRECHECK(TuneGetNoteAllocator);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &tp))
        return NULL;
    _rv = TuneGetNoteAllocator(tp);
    _res = Py_BuildValue("O&",
                         CmpInstObj_New, _rv);
    return _res;
}

static PyObject *Qt_TuneSetSofter(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
    long softer;
#ifndef TuneSetSofter
    PyMac_PRECHECK(TuneSetSofter);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &tp,
                          &softer))
        return NULL;
    _rv = TuneSetSofter(tp,
                        softer);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TuneTask(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
#ifndef TuneTask
    PyMac_PRECHECK(TuneTask);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &tp))
        return NULL;
    _rv = TuneTask(tp);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TuneSetBalance(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
    long balance;
#ifndef TuneSetBalance
    PyMac_PRECHECK(TuneSetBalance);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &tp,
                          &balance))
        return NULL;
    _rv = TuneSetBalance(tp,
                         balance);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TuneSetSoundLocalization(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
    Handle data;
#ifndef TuneSetSoundLocalization
    PyMac_PRECHECK(TuneSetSoundLocalization);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&",
                          CmpInstObj_Convert, &tp,
                          ResObj_Convert, &data))
        return NULL;
    _rv = TuneSetSoundLocalization(tp,
                                   data);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TuneSetHeaderWithSize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
    unsigned long * header;
    unsigned long size;
#ifndef TuneSetHeaderWithSize
    PyMac_PRECHECK(TuneSetHeaderWithSize);
#endif
    if (!PyArg_ParseTuple(_args, "O&sl",
                          CmpInstObj_Convert, &tp,
                          &header,
                          &size))
        return NULL;
    _rv = TuneSetHeaderWithSize(tp,
                                header,
                                size);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TuneSetPartMix(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
    unsigned long partNumber;
    long volume;
    long balance;
    long mixFlags;
#ifndef TuneSetPartMix
    PyMac_PRECHECK(TuneSetPartMix);
#endif
    if (!PyArg_ParseTuple(_args, "O&llll",
                          CmpInstObj_Convert, &tp,
                          &partNumber,
                          &volume,
                          &balance,
                          &mixFlags))
        return NULL;
    _rv = TuneSetPartMix(tp,
                         partNumber,
                         volume,
                         balance,
                         mixFlags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_TuneGetPartMix(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TunePlayer tp;
    unsigned long partNumber;
    long volumeOut;
    long balanceOut;
    long mixFlagsOut;
#ifndef TuneGetPartMix
    PyMac_PRECHECK(TuneGetPartMix);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          CmpInstObj_Convert, &tp,
                          &partNumber))
        return NULL;
    _rv = TuneGetPartMix(tp,
                         partNumber,
                         &volumeOut,
                         &balanceOut,
                         &mixFlagsOut);
    _res = Py_BuildValue("llll",
                         _rv,
                         volumeOut,
                         balanceOut,
                         mixFlagsOut);
    return _res;
}

static PyObject *Qt_AlignWindow(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    WindowPtr wp;
    Boolean front;
#ifndef AlignWindow
    PyMac_PRECHECK(AlignWindow);
#endif
    if (!PyArg_ParseTuple(_args, "O&b",
                          WinObj_Convert, &wp,
                          &front))
        return NULL;
    AlignWindow(wp,
                front,
                (Rect *)0,
                (ICMAlignmentProcRecordPtr)0);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_DragAlignedWindow(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    WindowPtr wp;
    Point startPt;
    Rect boundsRect;
#ifndef DragAlignedWindow
    PyMac_PRECHECK(DragAlignedWindow);
#endif
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          WinObj_Convert, &wp,
                          PyMac_GetPoint, &startPt,
                          PyMac_GetRect, &boundsRect))
        return NULL;
    DragAlignedWindow(wp,
                      startPt,
                      &boundsRect,
                      (Rect *)0,
                      (ICMAlignmentProcRecordPtr)0);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_MoviesTask(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long maxMilliSecToUse;
#ifndef MoviesTask
    PyMac_PRECHECK(MoviesTask);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &maxMilliSecToUse))
        return NULL;
    MoviesTask((Movie)0,
               maxMilliSecToUse);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}
#endif /* APPLE_SUPPORTS_QUICKTIME */

static PyMethodDef Qt_methods[] = {
#if APPLE_SUPPORTS_QUICKTIME
    {"EnterMovies", (PyCFunction)Qt_EnterMovies, 1,
     PyDoc_STR("() -> None")},
    {"ExitMovies", (PyCFunction)Qt_ExitMovies, 1,
     PyDoc_STR("() -> None")},
    {"GetMoviesError", (PyCFunction)Qt_GetMoviesError, 1,
     PyDoc_STR("() -> None")},
    {"ClearMoviesStickyError", (PyCFunction)Qt_ClearMoviesStickyError, 1,
     PyDoc_STR("() -> None")},
    {"GetMoviesStickyError", (PyCFunction)Qt_GetMoviesStickyError, 1,
     PyDoc_STR("() -> None")},
    {"QTGetWallClockTimeBase", (PyCFunction)Qt_QTGetWallClockTimeBase, 1,
     PyDoc_STR("() -> (TimeBase wallClockTimeBase)")},
    {"QTIdleManagerOpen", (PyCFunction)Qt_QTIdleManagerOpen, 1,
     PyDoc_STR("() -> (IdleManager _rv)")},
    {"CreateMovieControl", (PyCFunction)Qt_CreateMovieControl, 1,
     PyDoc_STR("(WindowPtr theWindow, Movie theMovie, UInt32 options) -> (Rect localRect, ControlHandle returnedControl)")},
    {"DisposeMatte", (PyCFunction)Qt_DisposeMatte, 1,
     PyDoc_STR("(PixMapHandle theMatte) -> None")},
    {"NewMovie", (PyCFunction)Qt_NewMovie, 1,
     PyDoc_STR("(long flags) -> (Movie _rv)")},
    {"QTGetTimeUntilNextTask", (PyCFunction)Qt_QTGetTimeUntilNextTask, 1,
     PyDoc_STR("(long scale) -> (long duration)")},
    {"GetDataHandler", (PyCFunction)Qt_GetDataHandler, 1,
     PyDoc_STR("(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)")},
    {"PasteHandleIntoMovie", (PyCFunction)Qt_PasteHandleIntoMovie, 1,
     PyDoc_STR("(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None")},
    {"GetMovieImporterForDataRef", (PyCFunction)Qt_GetMovieImporterForDataRef, 1,
     PyDoc_STR("(OSType dataRefType, Handle dataRef, long flags) -> (Component importer)")},
    {"QTGetMIMETypeInfo", (PyCFunction)Qt_QTGetMIMETypeInfo, 1,
     PyDoc_STR("(char* mimeStringStart, short mimeStringLength, OSType infoSelector, void * infoDataPtr) -> (long infoDataSize)")},
    {"TrackTimeToMediaTime", (PyCFunction)Qt_TrackTimeToMediaTime, 1,
     PyDoc_STR("(TimeValue value, Track theTrack) -> (TimeValue _rv)")},
    {"NewUserData", (PyCFunction)Qt_NewUserData, 1,
     PyDoc_STR("() -> (UserData theUserData)")},
    {"NewUserDataFromHandle", (PyCFunction)Qt_NewUserDataFromHandle, 1,
     PyDoc_STR("(Handle h) -> (UserData theUserData)")},
    {"CreateMovieFile", (PyCFunction)Qt_CreateMovieFile, 1,
     PyDoc_STR("(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (short resRefNum, Movie newmovie)")},
    {"OpenMovieFile", (PyCFunction)Qt_OpenMovieFile, 1,
     PyDoc_STR("(FSSpec fileSpec, SInt8 permission) -> (short resRefNum)")},
    {"CloseMovieFile", (PyCFunction)Qt_CloseMovieFile, 1,
     PyDoc_STR("(short resRefNum) -> None")},
    {"DeleteMovieFile", (PyCFunction)Qt_DeleteMovieFile, 1,
     PyDoc_STR("(FSSpec fileSpec) -> None")},
    {"NewMovieFromFile", (PyCFunction)Qt_NewMovieFromFile, 1,
     PyDoc_STR("(short resRefNum, short resId, short newMovieFlags) -> (Movie theMovie, short resId, Boolean dataRefWasChanged)")},
    {"NewMovieFromHandle", (PyCFunction)Qt_NewMovieFromHandle, 1,
     PyDoc_STR("(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")},
    {"NewMovieFromDataFork", (PyCFunction)Qt_NewMovieFromDataFork, 1,
     PyDoc_STR("(short fRefNum, long fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")},
    {"NewMovieFromDataFork64", (PyCFunction)Qt_NewMovieFromDataFork64, 1,
     PyDoc_STR("(long fRefNum, wide fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")},
    {"NewMovieFromDataRef", (PyCFunction)Qt_NewMovieFromDataRef, 1,
     PyDoc_STR("(short flags, Handle dataRef, OSType dtaRefType) -> (Movie m, short id)")},
    {"NewMovieFromStorageOffset", (PyCFunction)Qt_NewMovieFromStorageOffset, 1,
     PyDoc_STR("(DataHandler dh, wide fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasCataRefType)")},
    {"NewMovieForDataRefFromHandle", (PyCFunction)Qt_NewMovieForDataRefFromHandle, 1,
     PyDoc_STR("(Handle h, short newMovieFlags, Handle dataRef, OSType dataRefType) -> (Movie theMovie, Boolean dataRefWasChanged)")},
    {"RemoveMovieResource", (PyCFunction)Qt_RemoveMovieResource, 1,
     PyDoc_STR("(short resRefNum, short resId) -> None")},
    {"CreateMovieStorage", (PyCFunction)Qt_CreateMovieStorage, 1,
     PyDoc_STR("(Handle dataRef, OSType dataRefType, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (DataHandler outDataHandler, Movie newmovie)")},
    {"OpenMovieStorage", (PyCFunction)Qt_OpenMovieStorage, 1,
     PyDoc_STR("(Handle dataRef, OSType dataRefType, long flags) -> (DataHandler outDataHandler)")},
    {"CloseMovieStorage", (PyCFunction)Qt_CloseMovieStorage, 1,
     PyDoc_STR("(DataHandler dh) -> None")},
    {"DeleteMovieStorage", (PyCFunction)Qt_DeleteMovieStorage, 1,
     PyDoc_STR("(Handle dataRef, OSType dataRefType) -> None")},
    {"CreateShortcutMovieFile", (PyCFunction)Qt_CreateShortcutMovieFile, 1,
     PyDoc_STR("(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Handle targetDataRef, OSType targetDataRefType) -> None")},
    {"CanQuickTimeOpenFile", (PyCFunction)Qt_CanQuickTimeOpenFile, 1,
     PyDoc_STR("(FSSpec fileSpec, OSType fileType, OSType fileNameExtension, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)")},
    {"CanQuickTimeOpenDataRef", (PyCFunction)Qt_CanQuickTimeOpenDataRef, 1,
     PyDoc_STR("(Handle dataRef, OSType dataRefType, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)")},
    {"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1,
     PyDoc_STR("(long newMovieFlags) -> (Movie _rv)")},
    {"QTNewAlias", (PyCFunction)Qt_QTNewAlias, 1,
     PyDoc_STR("(FSSpec fss, Boolean minimal) -> (AliasHandle alias)")},
    {"EndFullScreen", (PyCFunction)Qt_EndFullScreen, 1,
     PyDoc_STR("(Ptr fullState, long flags) -> None")},
    {"AddSoundDescriptionExtension", (PyCFunction)Qt_AddSoundDescriptionExtension, 1,
     PyDoc_STR("(SoundDescriptionHandle desc, Handle extension, OSType idType) -> None")},
    {"GetSoundDescriptionExtension", (PyCFunction)Qt_GetSoundDescriptionExtension, 1,
     PyDoc_STR("(SoundDescriptionHandle desc, OSType idType) -> (Handle extension)")},
    {"RemoveSoundDescriptionExtension", (PyCFunction)Qt_RemoveSoundDescriptionExtension, 1,
     PyDoc_STR("(SoundDescriptionHandle desc, OSType idType) -> None")},
    {"QTIsStandardParameterDialogEvent", (PyCFunction)Qt_QTIsStandardParameterDialogEvent, 1,
     PyDoc_STR("(QTParameterDialog createdDialog) -> (EventRecord pEvent)")},
    {"QTDismissStandardParameterDialog", (PyCFunction)Qt_QTDismissStandardParameterDialog, 1,
     PyDoc_STR("(QTParameterDialog createdDialog) -> None")},
    {"QTStandardParameterDialogDoAction", (PyCFunction)Qt_QTStandardParameterDialogDoAction, 1,
     PyDoc_STR("(QTParameterDialog createdDialog, long action, void * params) -> None")},
    {"QTRegisterAccessKey", (PyCFunction)Qt_QTRegisterAccessKey, 1,
     PyDoc_STR("(Str255 accessKeyType, long flags, Handle accessKey) -> None")},
    {"QTUnregisterAccessKey", (PyCFunction)Qt_QTUnregisterAccessKey, 1,
     PyDoc_STR("(Str255 accessKeyType, long flags, Handle accessKey) -> None")},
    {"QTGetSupportedRestrictions", (PyCFunction)Qt_QTGetSupportedRestrictions, 1,
     PyDoc_STR("(OSType inRestrictionClass) -> (UInt32 outRestrictionIDs)")},
    {"QTTextToNativeText", (PyCFunction)Qt_QTTextToNativeText, 1,
     PyDoc_STR("(Handle theText, long encoding, long flags) -> None")},
    {"VideoMediaResetStatistics", (PyCFunction)Qt_VideoMediaResetStatistics, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
    {"VideoMediaGetStatistics", (PyCFunction)Qt_VideoMediaGetStatistics, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
    {"VideoMediaGetStallCount", (PyCFunction)Qt_VideoMediaGetStallCount, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, unsigned long stalls)")},
    {"VideoMediaSetCodecParameter", (PyCFunction)Qt_VideoMediaSetCodecParameter, 1,
     PyDoc_STR("(MediaHandler mh, CodecType cType, OSType parameterID, long parameterChangeSeed, void * dataPtr, long dataSize) -> (ComponentResult _rv)")},
    {"VideoMediaGetCodecParameter", (PyCFunction)Qt_VideoMediaGetCodecParameter, 1,
     PyDoc_STR("(MediaHandler mh, CodecType cType, OSType parameterID, Handle outParameterData) -> (ComponentResult _rv)")},
    {"TextMediaAddTextSample", (PyCFunction)Qt_TextMediaAddTextSample, 1,
     PyDoc_STR("(MediaHandler mh, Ptr text, unsigned long size, short fontNumber, short fontSize, Style textFace, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor textColor, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)")},
    {"TextMediaAddTESample", (PyCFunction)Qt_TextMediaAddTESample, 1,
     PyDoc_STR("(MediaHandler mh, TEHandle hTE, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)")},
    {"TextMediaAddHiliteSample", (PyCFunction)Qt_TextMediaAddHiliteSample, 1,
     PyDoc_STR("(MediaHandler mh, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor rgbHiliteColor, TimeValue sampleTime)")},
    {"TextMediaDrawRaw", (PyCFunction)Qt_TextMediaDrawRaw, 1,
     PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh) -> (ComponentResult _rv)")},
    {"TextMediaSetTextProperty", (PyCFunction)Qt_TextMediaSetTextProperty, 1,
     PyDoc_STR("(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)")},
    {"TextMediaRawSetup", (PyCFunction)Qt_TextMediaRawSetup, 1,
     PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh, TimeValue sampleDuration) -> (ComponentResult _rv)")},
    {"TextMediaRawIdle", (PyCFunction)Qt_TextMediaRawIdle, 1,
     PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, TimeValue sampleTime, long flagsIn) -> (ComponentResult _rv, long flagsOut)")},
    {"TextMediaGetTextProperty", (PyCFunction)Qt_TextMediaGetTextProperty, 1,
     PyDoc_STR("(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)")},
    {"TextMediaFindNextText", (PyCFunction)Qt_TextMediaFindNextText, 1,
     PyDoc_STR("(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)")},
    {"TextMediaHiliteTextSample", (PyCFunction)Qt_TextMediaHiliteTextSample, 1,
     PyDoc_STR("(MediaHandler mh, TimeValue sampleTime, short hiliteStart, short hiliteEnd) -> (ComponentResult _rv, RGBColor rgbHiliteColor)")},
    {"TextMediaSetTextSampleData", (PyCFunction)Qt_TextMediaSetTextSampleData, 1,
     PyDoc_STR("(MediaHandler mh, void * data, OSType dataType) -> (ComponentResult _rv)")},
    {"SpriteMediaSetProperty", (PyCFunction)Qt_SpriteMediaSetProperty, 1,
     PyDoc_STR("(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
    {"SpriteMediaGetProperty", (PyCFunction)Qt_SpriteMediaGetProperty, 1,
     PyDoc_STR("(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
    {"SpriteMediaHitTestSprites", (PyCFunction)Qt_SpriteMediaHitTestSprites, 1,
     PyDoc_STR("(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, short spriteHitIndex)")},
    {"SpriteMediaCountSprites", (PyCFunction)Qt_SpriteMediaCountSprites, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short numSprites)")},
    {"SpriteMediaCountImages", (PyCFunction)Qt_SpriteMediaCountImages, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short numImages)")},
    {"SpriteMediaGetIndImageDescription", (PyCFunction)Qt_SpriteMediaGetIndImageDescription, 1,
     PyDoc_STR("(MediaHandler mh, short imageIndex, ImageDescriptionHandle imageDescription) -> (ComponentResult _rv)")},
    {"SpriteMediaGetDisplayedSampleNumber", (PyCFunction)Qt_SpriteMediaGetDisplayedSampleNumber, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long sampleNum)")},
    {"SpriteMediaGetSpriteName", (PyCFunction)Qt_SpriteMediaGetSpriteName, 1,
     PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, Str255 spriteName) -> (ComponentResult _rv)")},
    {"SpriteMediaGetImageName", (PyCFunction)Qt_SpriteMediaGetImageName, 1,
     PyDoc_STR("(MediaHandler mh, short imageIndex, Str255 imageName) -> (ComponentResult _rv)")},
    {"SpriteMediaSetSpriteProperty", (PyCFunction)Qt_SpriteMediaSetSpriteProperty, 1,
     PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
    {"SpriteMediaGetSpriteProperty", (PyCFunction)Qt_SpriteMediaGetSpriteProperty, 1,
     PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
    {"SpriteMediaHitTestAllSprites", (PyCFunction)Qt_SpriteMediaHitTestAllSprites, 1,
     PyDoc_STR("(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, QTAtomID spriteHitID)")},
    {"SpriteMediaHitTestOneSprite", (PyCFunction)Qt_SpriteMediaHitTestOneSprite, 1,
     PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long flags, Point loc) -> (ComponentResult _rv, Boolean wasHit)")},
    {"SpriteMediaSpriteIndexToID", (PyCFunction)Qt_SpriteMediaSpriteIndexToID, 1,
     PyDoc_STR("(MediaHandler mh, short spriteIndex) -> (ComponentResult _rv, QTAtomID spriteID)")},
    {"SpriteMediaSpriteIDToIndex", (PyCFunction)Qt_SpriteMediaSpriteIDToIndex, 1,
     PyDoc_STR("(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv, short spriteIndex)")},
    {"SpriteMediaSetActionVariable", (PyCFunction)Qt_SpriteMediaSetActionVariable, 1,
     PyDoc_STR("(MediaHandler mh, QTAtomID variableID, float value) -> (ComponentResult _rv)")},
    {"SpriteMediaGetActionVariable", (PyCFunction)Qt_SpriteMediaGetActionVariable, 1,
     PyDoc_STR("(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, float value)")},
    {"SpriteMediaDisposeSprite", (PyCFunction)Qt_SpriteMediaDisposeSprite, 1,
     PyDoc_STR("(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv)")},
    {"SpriteMediaSetActionVariableToString", (PyCFunction)Qt_SpriteMediaSetActionVariableToString, 1,
     PyDoc_STR("(MediaHandler mh, QTAtomID variableID, Ptr theCString) -> (ComponentResult _rv)")},
    {"SpriteMediaGetActionVariableAsString", (PyCFunction)Qt_SpriteMediaGetActionVariableAsString, 1,
     PyDoc_STR("(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, Handle theCString)")},
    {"SpriteMediaNewImage", (PyCFunction)Qt_SpriteMediaNewImage, 1,
     PyDoc_STR("(MediaHandler mh, Handle dataRef, OSType dataRefType, QTAtomID desiredID) -> (ComponentResult _rv)")},
    {"SpriteMediaDisposeImage", (PyCFunction)Qt_SpriteMediaDisposeImage, 1,
     PyDoc_STR("(MediaHandler mh, short imageIndex) -> (ComponentResult _rv)")},
    {"SpriteMediaImageIndexToID", (PyCFunction)Qt_SpriteMediaImageIndexToID, 1,
     PyDoc_STR("(MediaHandler mh, short imageIndex) -> (ComponentResult _rv, QTAtomID imageID)")},
    {"SpriteMediaImageIDToIndex", (PyCFunction)Qt_SpriteMediaImageIDToIndex, 1,
     PyDoc_STR("(MediaHandler mh, QTAtomID imageID) -> (ComponentResult _rv, short imageIndex)")},
    {"FlashMediaSetPan", (PyCFunction)Qt_FlashMediaSetPan, 1,
     PyDoc_STR("(MediaHandler mh, short xPercent, short yPercent) -> (ComponentResult _rv)")},
    {"FlashMediaSetZoom", (PyCFunction)Qt_FlashMediaSetZoom, 1,
     PyDoc_STR("(MediaHandler mh, short factor) -> (ComponentResult _rv)")},
    {"FlashMediaSetZoomRect", (PyCFunction)Qt_FlashMediaSetZoomRect, 1,
     PyDoc_STR("(MediaHandler mh, long left, long top, long right, long bottom) -> (ComponentResult _rv)")},
    {"FlashMediaGetRefConBounds", (PyCFunction)Qt_FlashMediaGetRefConBounds, 1,
     PyDoc_STR("(MediaHandler mh, long refCon) -> (ComponentResult _rv, long left, long top, long right, long bottom)")},
    {"FlashMediaGetRefConID", (PyCFunction)Qt_FlashMediaGetRefConID, 1,
     PyDoc_STR("(MediaHandler mh, long refCon) -> (ComponentResult _rv, long refConID)")},
    {"FlashMediaIDToRefCon", (PyCFunction)Qt_FlashMediaIDToRefCon, 1,
     PyDoc_STR("(MediaHandler mh, long refConID) -> (ComponentResult _rv, long refCon)")},
    {"FlashMediaGetDisplayedFrameNumber", (PyCFunction)Qt_FlashMediaGetDisplayedFrameNumber, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long flashFrameNumber)")},
    {"FlashMediaFrameNumberToMovieTime", (PyCFunction)Qt_FlashMediaFrameNumberToMovieTime, 1,
     PyDoc_STR("(MediaHandler mh, long flashFrameNumber) -> (ComponentResult _rv, TimeValue movieTime)")},
    {"FlashMediaFrameLabelToMovieTime", (PyCFunction)Qt_FlashMediaFrameLabelToMovieTime, 1,
     PyDoc_STR("(MediaHandler mh, Ptr theLabel) -> (ComponentResult _rv, TimeValue movieTime)")},
    {"FlashMediaGetFlashVariable", (PyCFunction)Qt_FlashMediaGetFlashVariable, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, char path, char name, Handle theVariableCStringOut)")},
    {"FlashMediaSetFlashVariable", (PyCFunction)Qt_FlashMediaSetFlashVariable, 1,
     PyDoc_STR("(MediaHandler mh, Boolean updateFocus) -> (ComponentResult _rv, char path, char name, char value)")},
    {"FlashMediaDoButtonActions", (PyCFunction)Qt_FlashMediaDoButtonActions, 1,
     PyDoc_STR("(MediaHandler mh, long buttonID, long transition) -> (ComponentResult _rv, char path)")},
    {"FlashMediaGetSupportedSwfVersion", (PyCFunction)Qt_FlashMediaGetSupportedSwfVersion, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, UInt8 swfVersion)")},
    {"Media3DGetCurrentGroup", (PyCFunction)Qt_Media3DGetCurrentGroup, 1,
     PyDoc_STR("(MediaHandler mh, void * group) -> (ComponentResult _rv)")},
    {"Media3DTranslateNamedObjectTo", (PyCFunction)Qt_Media3DTranslateNamedObjectTo, 1,
     PyDoc_STR("(MediaHandler mh, Fixed x, Fixed y, Fixed z) -> (ComponentResult _rv, char objectName)")},
    {"Media3DScaleNamedObjectTo", (PyCFunction)Qt_Media3DScaleNamedObjectTo, 1,
     PyDoc_STR("(MediaHandler mh, Fixed xScale, Fixed yScale, Fixed zScale) -> (ComponentResult _rv, char objectName)")},
    {"Media3DRotateNamedObjectTo", (PyCFunction)Qt_Media3DRotateNamedObjectTo, 1,
     PyDoc_STR("(MediaHandler mh, Fixed xDegrees, Fixed yDegrees, Fixed zDegrees) -> (ComponentResult _rv, char objectName)")},
    {"Media3DSetCameraData", (PyCFunction)Qt_Media3DSetCameraData, 1,
     PyDoc_STR("(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)")},
    {"Media3DGetCameraData", (PyCFunction)Qt_Media3DGetCameraData, 1,
     PyDoc_STR("(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)")},
    {"Media3DSetCameraAngleAspect", (PyCFunction)Qt_Media3DSetCameraAngleAspect, 1,
     PyDoc_STR("(MediaHandler mh, QTFloatSingle fov, QTFloatSingle aspectRatioXToY) -> (ComponentResult _rv)")},
    {"Media3DGetCameraAngleAspect", (PyCFunction)Qt_Media3DGetCameraAngleAspect, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, QTFloatSingle fov, QTFloatSingle aspectRatioXToY)")},
    {"Media3DSetCameraRange", (PyCFunction)Qt_Media3DSetCameraRange, 1,
     PyDoc_STR("(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)")},
    {"Media3DGetCameraRange", (PyCFunction)Qt_Media3DGetCameraRange, 1,
     PyDoc_STR("(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)")},
    {"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1,
     PyDoc_STR("() -> (TimeBase _rv)")},
    {"ConvertTime", (PyCFunction)Qt_ConvertTime, 1,
     PyDoc_STR("(TimeRecord theTime, TimeBase newBase) -> (TimeRecord theTime)")},
    {"ConvertTimeScale", (PyCFunction)Qt_ConvertTimeScale, 1,
     PyDoc_STR("(TimeRecord theTime, TimeScale newScale) -> (TimeRecord theTime)")},
    {"AddTime", (PyCFunction)Qt_AddTime, 1,
     PyDoc_STR("(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)")},
    {"SubtractTime", (PyCFunction)Qt_SubtractTime, 1,
     PyDoc_STR("(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)")},
    {"MusicMediaGetIndexedTunePlayer", (PyCFunction)Qt_MusicMediaGetIndexedTunePlayer, 1,
     PyDoc_STR("(ComponentInstance ti, long sampleDescIndex) -> (ComponentResult _rv, ComponentInstance tp)")},
    {"CodecManagerVersion", (PyCFunction)Qt_CodecManagerVersion, 1,
     PyDoc_STR("() -> (long version)")},
    {"GetMaxCompressionSize", (PyCFunction)Qt_GetMaxCompressionSize, 1,
     PyDoc_STR("(PixMapHandle src, Rect srcRect, short colorDepth, CodecQ quality, CodecType cType, CompressorComponent codec) -> (long size)")},
    {"GetCompressionTime", (PyCFunction)Qt_GetCompressionTime, 1,
     PyDoc_STR("(PixMapHandle src, Rect srcRect, short colorDepth, CodecType cType, CompressorComponent codec) -> (CodecQ spatialQuality, CodecQ temporalQuality, unsigned long compressTime)")},
    {"CompressImage", (PyCFunction)Qt_CompressImage, 1,
     PyDoc_STR("(PixMapHandle src, Rect srcRect, CodecQ quality, CodecType cType, ImageDescriptionHandle desc, Ptr data) -> None")},
    {"DecompressImage", (PyCFunction)Qt_DecompressImage, 1,
     PyDoc_STR("(Ptr data, ImageDescriptionHandle desc, PixMapHandle dst, Rect srcRect, Rect dstRect, short mode, RgnHandle mask) -> None")},
    {"GetSimilarity", (PyCFunction)Qt_GetSimilarity, 1,
     PyDoc_STR("(PixMapHandle src, Rect srcRect, ImageDescriptionHandle desc, Ptr data) -> (Fixed similarity)")},
    {"GetImageDescriptionCTable", (PyCFunction)Qt_GetImageDescriptionCTable, 1,
     PyDoc_STR("(ImageDescriptionHandle desc) -> (CTabHandle ctable)")},
    {"SetImageDescriptionCTable", (PyCFunction)Qt_SetImageDescriptionCTable, 1,
     PyDoc_STR("(ImageDescriptionHandle desc, CTabHandle ctable) -> None")},
    {"GetImageDescriptionExtension", (PyCFunction)Qt_GetImageDescriptionExtension, 1,
     PyDoc_STR("(ImageDescriptionHandle desc, long idType, long index) -> (Handle extension)")},
    {"AddImageDescriptionExtension", (PyCFunction)Qt_AddImageDescriptionExtension, 1,
     PyDoc_STR("(ImageDescriptionHandle desc, Handle extension, long idType) -> None")},
    {"RemoveImageDescriptionExtension", (PyCFunction)Qt_RemoveImageDescriptionExtension, 1,
     PyDoc_STR("(ImageDescriptionHandle desc, long idType, long index) -> None")},
    {"CountImageDescriptionExtensionType", (PyCFunction)Qt_CountImageDescriptionExtensionType, 1,
     PyDoc_STR("(ImageDescriptionHandle desc, long idType) -> (long count)")},
    {"GetNextImageDescriptionExtensionType", (PyCFunction)Qt_GetNextImageDescriptionExtensionType, 1,
     PyDoc_STR("(ImageDescriptionHandle desc) -> (long idType)")},
    {"FindCodec", (PyCFunction)Qt_FindCodec, 1,
     PyDoc_STR("(CodecType cType, CodecComponent specCodec) -> (CompressorComponent compressor, DecompressorComponent decompressor)")},
    {"CompressPicture", (PyCFunction)Qt_CompressPicture, 1,
     PyDoc_STR("(PicHandle srcPicture, PicHandle dstPicture, CodecQ quality, CodecType cType) -> None")},
    {"CompressPictureFile", (PyCFunction)Qt_CompressPictureFile, 1,
     PyDoc_STR("(short srcRefNum, short dstRefNum, CodecQ quality, CodecType cType) -> None")},
    {"ConvertImage", (PyCFunction)Qt_ConvertImage, 1,
     PyDoc_STR("(ImageDescriptionHandle srcDD, Ptr srcData, short colorDepth, CTabHandle ctable, CodecQ accuracy, CodecQ quality, CodecType cType, CodecComponent codec, ImageDescriptionHandle dstDD, Ptr dstData) -> None")},
    {"AddFilePreview", (PyCFunction)Qt_AddFilePreview, 1,
     PyDoc_STR("(short resRefNum, OSType previewType, Handle previewData) -> None")},
    {"GetBestDeviceRect", (PyCFunction)Qt_GetBestDeviceRect, 1,
     PyDoc_STR("() -> (GDHandle gdh, Rect rp)")},
    {"GDHasScale", (PyCFunction)Qt_GDHasScale, 1,
     PyDoc_STR("(GDHandle gdh, short depth) -> (Fixed scale)")},
    {"GDGetScale", (PyCFunction)Qt_GDGetScale, 1,
     PyDoc_STR("(GDHandle gdh) -> (Fixed scale, short flags)")},
    {"GDSetScale", (PyCFunction)Qt_GDSetScale, 1,
     PyDoc_STR("(GDHandle gdh, Fixed scale, short flags) -> None")},
    {"GetGraphicsImporterForFile", (PyCFunction)Qt_GetGraphicsImporterForFile, 1,
     PyDoc_STR("(FSSpec theFile) -> (ComponentInstance gi)")},
    {"GetGraphicsImporterForDataRef", (PyCFunction)Qt_GetGraphicsImporterForDataRef, 1,
     PyDoc_STR("(Handle dataRef, OSType dataRefType) -> (ComponentInstance gi)")},
    {"GetGraphicsImporterForFileWithFlags", (PyCFunction)Qt_GetGraphicsImporterForFileWithFlags, 1,
     PyDoc_STR("(FSSpec theFile, long flags) -> (ComponentInstance gi)")},
    {"GetGraphicsImporterForDataRefWithFlags", (PyCFunction)Qt_GetGraphicsImporterForDataRefWithFlags, 1,
     PyDoc_STR("(Handle dataRef, OSType dataRefType, long flags) -> (ComponentInstance gi)")},
    {"MakeImageDescriptionForPixMap", (PyCFunction)Qt_MakeImageDescriptionForPixMap, 1,
     PyDoc_STR("(PixMapHandle pixmap) -> (ImageDescriptionHandle idh)")},
    {"MakeImageDescriptionForEffect", (PyCFunction)Qt_MakeImageDescriptionForEffect, 1,
     PyDoc_STR("(OSType effectType) -> (ImageDescriptionHandle idh)")},
    {"QTGetPixelSize", (PyCFunction)Qt_QTGetPixelSize, 1,
     PyDoc_STR("(OSType PixelFormat) -> (short _rv)")},
    {"QTGetPixelFormatDepthForImageDescription", (PyCFunction)Qt_QTGetPixelFormatDepthForImageDescription, 1,
     PyDoc_STR("(OSType PixelFormat) -> (short _rv)")},
    {"QTGetPixMapHandleRowBytes", (PyCFunction)Qt_QTGetPixMapHandleRowBytes, 1,
     PyDoc_STR("(PixMapHandle pm) -> (long _rv)")},
    {"QTSetPixMapHandleRowBytes", (PyCFunction)Qt_QTSetPixMapHandleRowBytes, 1,
     PyDoc_STR("(PixMapHandle pm, long rowBytes) -> None")},
    {"QTGetPixMapHandleGammaLevel", (PyCFunction)Qt_QTGetPixMapHandleGammaLevel, 1,
     PyDoc_STR("(PixMapHandle pm) -> (Fixed _rv)")},
    {"QTSetPixMapHandleGammaLevel", (PyCFunction)Qt_QTSetPixMapHandleGammaLevel, 1,
     PyDoc_STR("(PixMapHandle pm, Fixed gammaLevel) -> None")},
    {"QTGetPixMapHandleRequestedGammaLevel", (PyCFunction)Qt_QTGetPixMapHandleRequestedGammaLevel, 1,
     PyDoc_STR("(PixMapHandle pm) -> (Fixed _rv)")},
    {"QTSetPixMapHandleRequestedGammaLevel", (PyCFunction)Qt_QTSetPixMapHandleRequestedGammaLevel, 1,
     PyDoc_STR("(PixMapHandle pm, Fixed requestedGammaLevel) -> None")},
    {"CompAdd", (PyCFunction)Qt_CompAdd, 1,
     PyDoc_STR("() -> (wide src, wide dst)")},
    {"CompSub", (PyCFunction)Qt_CompSub, 1,
     PyDoc_STR("() -> (wide src, wide dst)")},
    {"CompNeg", (PyCFunction)Qt_CompNeg, 1,
     PyDoc_STR("() -> (wide dst)")},
    {"CompShift", (PyCFunction)Qt_CompShift, 1,
     PyDoc_STR("(short shift) -> (wide src)")},
    {"CompMul", (PyCFunction)Qt_CompMul, 1,
     PyDoc_STR("(long src1, long src2) -> (wide dst)")},
    {"CompDiv", (PyCFunction)Qt_CompDiv, 1,
     PyDoc_STR("(long denominator) -> (long _rv, wide numerator, long remainder)")},
    {"CompFixMul", (PyCFunction)Qt_CompFixMul, 1,
     PyDoc_STR("(Fixed fixSrc) -> (wide compSrc, wide compDst)")},
    {"CompMulDiv", (PyCFunction)Qt_CompMulDiv, 1,
     PyDoc_STR("(long mul, long divisor) -> (wide co)")},
    {"CompMulDivTrunc", (PyCFunction)Qt_CompMulDivTrunc, 1,
     PyDoc_STR("(long mul, long divisor) -> (wide co, long remainder)")},
    {"CompCompare", (PyCFunction)Qt_CompCompare, 1,
     PyDoc_STR("(wide a, wide minusb) -> (long _rv)")},
    {"CompSquareRoot", (PyCFunction)Qt_CompSquareRoot, 1,
     PyDoc_STR("(wide src) -> (unsigned long _rv)")},
    {"FixMulDiv", (PyCFunction)Qt_FixMulDiv, 1,
     PyDoc_STR("(Fixed src, Fixed mul, Fixed divisor) -> (Fixed _rv)")},
    {"UnsignedFixMulDiv", (PyCFunction)Qt_UnsignedFixMulDiv, 1,
     PyDoc_STR("(Fixed src, Fixed mul, Fixed divisor) -> (Fixed _rv)")},
    {"FixExp2", (PyCFunction)Qt_FixExp2, 1,
     PyDoc_STR("(Fixed src) -> (Fixed _rv)")},
    {"FixLog2", (PyCFunction)Qt_FixLog2, 1,
     PyDoc_STR("(Fixed src) -> (Fixed _rv)")},
    {"FixPow", (PyCFunction)Qt_FixPow, 1,
     PyDoc_STR("(Fixed base, Fixed exp) -> (Fixed _rv)")},
    {"GraphicsImportSetDataReference", (PyCFunction)Qt_GraphicsImportSetDataReference, 1,
     PyDoc_STR("(GraphicsImportComponent ci, Handle dataRef, OSType dataReType) -> (ComponentResult _rv)")},
    {"GraphicsImportGetDataReference", (PyCFunction)Qt_GraphicsImportGetDataReference, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Handle dataRef, OSType dataReType)")},
    {"GraphicsImportSetDataFile", (PyCFunction)Qt_GraphicsImportSetDataFile, 1,
     PyDoc_STR("(GraphicsImportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")},
    {"GraphicsImportGetDataFile", (PyCFunction)Qt_GraphicsImportGetDataFile, 1,
     PyDoc_STR("(GraphicsImportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")},
    {"GraphicsImportSetDataHandle", (PyCFunction)Qt_GraphicsImportSetDataHandle, 1,
     PyDoc_STR("(GraphicsImportComponent ci, Handle h) -> (ComponentResult _rv)")},
    {"GraphicsImportGetDataHandle", (PyCFunction)Qt_GraphicsImportGetDataHandle, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Handle h)")},
    {"GraphicsImportGetImageDescription", (PyCFunction)Qt_GraphicsImportGetImageDescription, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, ImageDescriptionHandle desc)")},
    {"GraphicsImportGetDataOffsetAndSize", (PyCFunction)Qt_GraphicsImportGetDataOffsetAndSize, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, unsigned long offset, unsigned long size)")},
    {"GraphicsImportReadData", (PyCFunction)Qt_GraphicsImportReadData, 1,
     PyDoc_STR("(GraphicsImportComponent ci, void * dataPtr, unsigned long dataOffset, unsigned long dataSize) -> (ComponentResult _rv)")},
    {"GraphicsImportSetClip", (PyCFunction)Qt_GraphicsImportSetClip, 1,
     PyDoc_STR("(GraphicsImportComponent ci, RgnHandle clipRgn) -> (ComponentResult _rv)")},
    {"GraphicsImportGetClip", (PyCFunction)Qt_GraphicsImportGetClip, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, RgnHandle clipRgn)")},
    {"GraphicsImportSetSourceRect", (PyCFunction)Qt_GraphicsImportSetSourceRect, 1,
     PyDoc_STR("(GraphicsImportComponent ci, Rect sourceRect) -> (ComponentResult _rv)")},
    {"GraphicsImportGetSourceRect", (PyCFunction)Qt_GraphicsImportGetSourceRect, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect sourceRect)")},
    {"GraphicsImportGetNaturalBounds", (PyCFunction)Qt_GraphicsImportGetNaturalBounds, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect naturalBounds)")},
    {"GraphicsImportDraw", (PyCFunction)Qt_GraphicsImportDraw, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv)")},
    {"GraphicsImportSetGWorld", (PyCFunction)Qt_GraphicsImportSetGWorld, 1,
     PyDoc_STR("(GraphicsImportComponent ci, CGrafPtr port, GDHandle gd) -> (ComponentResult _rv)")},
    {"GraphicsImportGetGWorld", (PyCFunction)Qt_GraphicsImportGetGWorld, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, CGrafPtr port, GDHandle gd)")},
    {"GraphicsImportSetBoundsRect", (PyCFunction)Qt_GraphicsImportSetBoundsRect, 1,
     PyDoc_STR("(GraphicsImportComponent ci, Rect bounds) -> (ComponentResult _rv)")},
    {"GraphicsImportGetBoundsRect", (PyCFunction)Qt_GraphicsImportGetBoundsRect, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect bounds)")},
    {"GraphicsImportSaveAsPicture", (PyCFunction)Qt_GraphicsImportSaveAsPicture, 1,
     PyDoc_STR("(GraphicsImportComponent ci, FSSpec fss, ScriptCode scriptTag) -> (ComponentResult _rv)")},
    {"GraphicsImportSetGraphicsMode", (PyCFunction)Qt_GraphicsImportSetGraphicsMode, 1,
     PyDoc_STR("(GraphicsImportComponent ci, long graphicsMode, RGBColor opColor) -> (ComponentResult _rv)")},
    {"GraphicsImportGetGraphicsMode", (PyCFunction)Qt_GraphicsImportGetGraphicsMode, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, long graphicsMode, RGBColor opColor)")},
    {"GraphicsImportSetQuality", (PyCFunction)Qt_GraphicsImportSetQuality, 1,
     PyDoc_STR("(GraphicsImportComponent ci, CodecQ quality) -> (ComponentResult _rv)")},
    {"GraphicsImportGetQuality", (PyCFunction)Qt_GraphicsImportGetQuality, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, CodecQ quality)")},
    {"GraphicsImportSaveAsQuickTimeImageFile", (PyCFunction)Qt_GraphicsImportSaveAsQuickTimeImageFile, 1,
     PyDoc_STR("(GraphicsImportComponent ci, FSSpec fss, ScriptCode scriptTag) -> (ComponentResult _rv)")},
    {"GraphicsImportSetDataReferenceOffsetAndLimit", (PyCFunction)Qt_GraphicsImportSetDataReferenceOffsetAndLimit, 1,
     PyDoc_STR("(GraphicsImportComponent ci, unsigned long offset, unsigned long limit) -> (ComponentResult _rv)")},
    {"GraphicsImportGetDataReferenceOffsetAndLimit", (PyCFunction)Qt_GraphicsImportGetDataReferenceOffsetAndLimit, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, unsigned long offset, unsigned long limit)")},
    {"GraphicsImportGetAliasedDataReference", (PyCFunction)Qt_GraphicsImportGetAliasedDataReference, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType)")},
    {"GraphicsImportValidate", (PyCFunction)Qt_GraphicsImportValidate, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Boolean valid)")},
    {"GraphicsImportGetMetaData", (PyCFunction)Qt_GraphicsImportGetMetaData, 1,
     PyDoc_STR("(GraphicsImportComponent ci, void * userData) -> (ComponentResult _rv)")},
    {"GraphicsImportGetMIMETypeList", (PyCFunction)Qt_GraphicsImportGetMIMETypeList, 1,
     PyDoc_STR("(GraphicsImportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")},
    {"GraphicsImportDoesDrawAllPixels", (PyCFunction)Qt_GraphicsImportDoesDrawAllPixels, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, short drawsAllPixels)")},
    {"GraphicsImportGetAsPicture", (PyCFunction)Qt_GraphicsImportGetAsPicture, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, PicHandle picture)")},
    {"GraphicsImportExportImageFile", (PyCFunction)Qt_GraphicsImportExportImageFile, 1,
     PyDoc_STR("(GraphicsImportComponent ci, OSType fileType, OSType fileCreator, FSSpec fss, ScriptCode scriptTag) -> (ComponentResult _rv)")},
    {"GraphicsImportGetExportImageTypeList", (PyCFunction)Qt_GraphicsImportGetExportImageTypeList, 1,
     PyDoc_STR("(GraphicsImportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")},
    {"GraphicsImportGetExportSettingsAsAtomContainer", (PyCFunction)Qt_GraphicsImportGetExportSettingsAsAtomContainer, 1,
     PyDoc_STR("(GraphicsImportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")},
    {"GraphicsImportSetExportSettingsFromAtomContainer", (PyCFunction)Qt_GraphicsImportSetExportSettingsFromAtomContainer, 1,
     PyDoc_STR("(GraphicsImportComponent ci, void * qtAtomContainer) -> (ComponentResult _rv)")},
    {"GraphicsImportGetImageCount", (PyCFunction)Qt_GraphicsImportGetImageCount, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, unsigned long imageCount)")},
    {"GraphicsImportSetImageIndex", (PyCFunction)Qt_GraphicsImportSetImageIndex, 1,
     PyDoc_STR("(GraphicsImportComponent ci, unsigned long imageIndex) -> (ComponentResult _rv)")},
    {"GraphicsImportGetImageIndex", (PyCFunction)Qt_GraphicsImportGetImageIndex, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, unsigned long imageIndex)")},
    {"GraphicsImportGetDataOffsetAndSize64", (PyCFunction)Qt_GraphicsImportGetDataOffsetAndSize64, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, wide offset, wide size)")},
    {"GraphicsImportReadData64", (PyCFunction)Qt_GraphicsImportReadData64, 1,
     PyDoc_STR("(GraphicsImportComponent ci, void * dataPtr, wide dataOffset, unsigned long dataSize) -> (ComponentResult _rv)")},
    {"GraphicsImportSetDataReferenceOffsetAndLimit64", (PyCFunction)Qt_GraphicsImportSetDataReferenceOffsetAndLimit64, 1,
     PyDoc_STR("(GraphicsImportComponent ci, wide offset, wide limit) -> (ComponentResult _rv)")},
    {"GraphicsImportGetDataReferenceOffsetAndLimit64", (PyCFunction)Qt_GraphicsImportGetDataReferenceOffsetAndLimit64, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, wide offset, wide limit)")},
    {"GraphicsImportGetDefaultClip", (PyCFunction)Qt_GraphicsImportGetDefaultClip, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, RgnHandle defaultRgn)")},
    {"GraphicsImportGetDefaultGraphicsMode", (PyCFunction)Qt_GraphicsImportGetDefaultGraphicsMode, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, long defaultGraphicsMode, RGBColor defaultOpColor)")},
    {"GraphicsImportGetDefaultSourceRect", (PyCFunction)Qt_GraphicsImportGetDefaultSourceRect, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect defaultSourceRect)")},
    {"GraphicsImportGetColorSyncProfile", (PyCFunction)Qt_GraphicsImportGetColorSyncProfile, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Handle profile)")},
    {"GraphicsImportSetDestRect", (PyCFunction)Qt_GraphicsImportSetDestRect, 1,
     PyDoc_STR("(GraphicsImportComponent ci, Rect destRect) -> (ComponentResult _rv)")},
    {"GraphicsImportGetDestRect", (PyCFunction)Qt_GraphicsImportGetDestRect, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect destRect)")},
    {"GraphicsImportSetFlags", (PyCFunction)Qt_GraphicsImportSetFlags, 1,
     PyDoc_STR("(GraphicsImportComponent ci, long flags) -> (ComponentResult _rv)")},
    {"GraphicsImportGetFlags", (PyCFunction)Qt_GraphicsImportGetFlags, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, long flags)")},
    {"GraphicsImportGetBaseDataOffsetAndSize64", (PyCFunction)Qt_GraphicsImportGetBaseDataOffsetAndSize64, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, wide offset, wide size)")},
    {"GraphicsImportSetImageIndexToThumbnail", (PyCFunction)Qt_GraphicsImportSetImageIndexToThumbnail, 1,
     PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv)")},
    {"GraphicsExportDoExport", (PyCFunction)Qt_GraphicsExportDoExport, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long actualSizeWritten)")},
    {"GraphicsExportCanTranscode", (PyCFunction)Qt_GraphicsExportCanTranscode, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean canTranscode)")},
    {"GraphicsExportDoTranscode", (PyCFunction)Qt_GraphicsExportDoTranscode, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv)")},
    {"GraphicsExportCanUseCompressor", (PyCFunction)Qt_GraphicsExportCanUseCompressor, 1,
     PyDoc_STR("(GraphicsExportComponent ci, void * codecSettingsAtomContainerPtr) -> (ComponentResult _rv, Boolean canUseCompressor)")},
    {"GraphicsExportDoUseCompressor", (PyCFunction)Qt_GraphicsExportDoUseCompressor, 1,
     PyDoc_STR("(GraphicsExportComponent ci, void * codecSettingsAtomContainer) -> (ComponentResult _rv, ImageDescriptionHandle outDesc)")},
    {"GraphicsExportDoStandaloneExport", (PyCFunction)Qt_GraphicsExportDoStandaloneExport, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv)")},
    {"GraphicsExportGetDefaultFileTypeAndCreator", (PyCFunction)Qt_GraphicsExportGetDefaultFileTypeAndCreator, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, OSType fileType, OSType fileCreator)")},
    {"GraphicsExportGetDefaultFileNameExtension", (PyCFunction)Qt_GraphicsExportGetDefaultFileNameExtension, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, OSType fileNameExtension)")},
    {"GraphicsExportGetMIMETypeList", (PyCFunction)Qt_GraphicsExportGetMIMETypeList, 1,
     PyDoc_STR("(GraphicsExportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")},
    {"GraphicsExportSetSettingsFromAtomContainer", (PyCFunction)Qt_GraphicsExportSetSettingsFromAtomContainer, 1,
     PyDoc_STR("(GraphicsExportComponent ci, void * qtAtomContainer) -> (ComponentResult _rv)")},
    {"GraphicsExportGetSettingsAsAtomContainer", (PyCFunction)Qt_GraphicsExportGetSettingsAsAtomContainer, 1,
     PyDoc_STR("(GraphicsExportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")},
    {"GraphicsExportGetSettingsAsText", (PyCFunction)Qt_GraphicsExportGetSettingsAsText, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle theText)")},
    {"GraphicsExportSetDontRecompress", (PyCFunction)Qt_GraphicsExportSetDontRecompress, 1,
     PyDoc_STR("(GraphicsExportComponent ci, Boolean dontRecompress) -> (ComponentResult _rv)")},
    {"GraphicsExportGetDontRecompress", (PyCFunction)Qt_GraphicsExportGetDontRecompress, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean dontRecompress)")},
    {"GraphicsExportSetInterlaceStyle", (PyCFunction)Qt_GraphicsExportSetInterlaceStyle, 1,
     PyDoc_STR("(GraphicsExportComponent ci, unsigned long interlaceStyle) -> (ComponentResult _rv)")},
    {"GraphicsExportGetInterlaceStyle", (PyCFunction)Qt_GraphicsExportGetInterlaceStyle, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long interlaceStyle)")},
    {"GraphicsExportSetMetaData", (PyCFunction)Qt_GraphicsExportSetMetaData, 1,
     PyDoc_STR("(GraphicsExportComponent ci, void * userData) -> (ComponentResult _rv)")},
    {"GraphicsExportGetMetaData", (PyCFunction)Qt_GraphicsExportGetMetaData, 1,
     PyDoc_STR("(GraphicsExportComponent ci, void * userData) -> (ComponentResult _rv)")},
    {"GraphicsExportSetTargetDataSize", (PyCFunction)Qt_GraphicsExportSetTargetDataSize, 1,
     PyDoc_STR("(GraphicsExportComponent ci, unsigned long targetDataSize) -> (ComponentResult _rv)")},
    {"GraphicsExportGetTargetDataSize", (PyCFunction)Qt_GraphicsExportGetTargetDataSize, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long targetDataSize)")},
    {"GraphicsExportSetCompressionMethod", (PyCFunction)Qt_GraphicsExportSetCompressionMethod, 1,
     PyDoc_STR("(GraphicsExportComponent ci, long compressionMethod) -> (ComponentResult _rv)")},
    {"GraphicsExportGetCompressionMethod", (PyCFunction)Qt_GraphicsExportGetCompressionMethod, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, long compressionMethod)")},
    {"GraphicsExportSetCompressionQuality", (PyCFunction)Qt_GraphicsExportSetCompressionQuality, 1,
     PyDoc_STR("(GraphicsExportComponent ci, CodecQ spatialQuality) -> (ComponentResult _rv)")},
    {"GraphicsExportGetCompressionQuality", (PyCFunction)Qt_GraphicsExportGetCompressionQuality, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, CodecQ spatialQuality)")},
    {"GraphicsExportSetResolution", (PyCFunction)Qt_GraphicsExportSetResolution, 1,
     PyDoc_STR("(GraphicsExportComponent ci, Fixed horizontalResolution, Fixed verticalResolution) -> (ComponentResult _rv)")},
    {"GraphicsExportGetResolution", (PyCFunction)Qt_GraphicsExportGetResolution, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Fixed horizontalResolution, Fixed verticalResolution)")},
    {"GraphicsExportSetDepth", (PyCFunction)Qt_GraphicsExportSetDepth, 1,
     PyDoc_STR("(GraphicsExportComponent ci, long depth) -> (ComponentResult _rv)")},
    {"GraphicsExportGetDepth", (PyCFunction)Qt_GraphicsExportGetDepth, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, long depth)")},
    {"GraphicsExportSetColorSyncProfile", (PyCFunction)Qt_GraphicsExportSetColorSyncProfile, 1,
     PyDoc_STR("(GraphicsExportComponent ci, Handle colorSyncProfile) -> (ComponentResult _rv)")},
    {"GraphicsExportGetColorSyncProfile", (PyCFunction)Qt_GraphicsExportGetColorSyncProfile, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle colorSyncProfile)")},
    {"GraphicsExportSetInputDataReference", (PyCFunction)Qt_GraphicsExportSetInputDataReference, 1,
     PyDoc_STR("(GraphicsExportComponent ci, Handle dataRef, OSType dataRefType, ImageDescriptionHandle desc) -> (ComponentResult _rv)")},
    {"GraphicsExportGetInputDataReference", (PyCFunction)Qt_GraphicsExportGetInputDataReference, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType)")},
    {"GraphicsExportSetInputFile", (PyCFunction)Qt_GraphicsExportSetInputFile, 1,
     PyDoc_STR("(GraphicsExportComponent ci, FSSpec theFile, ImageDescriptionHandle desc) -> (ComponentResult _rv)")},
    {"GraphicsExportGetInputFile", (PyCFunction)Qt_GraphicsExportGetInputFile, 1,
     PyDoc_STR("(GraphicsExportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")},
    {"GraphicsExportSetInputHandle", (PyCFunction)Qt_GraphicsExportSetInputHandle, 1,
     PyDoc_STR("(GraphicsExportComponent ci, Handle h, ImageDescriptionHandle desc) -> (ComponentResult _rv)")},
    {"GraphicsExportGetInputHandle", (PyCFunction)Qt_GraphicsExportGetInputHandle, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle h)")},
    {"GraphicsExportSetInputPtr", (PyCFunction)Qt_GraphicsExportSetInputPtr, 1,
     PyDoc_STR("(GraphicsExportComponent ci, Ptr p, unsigned long size, ImageDescriptionHandle desc) -> (ComponentResult _rv)")},
    {"GraphicsExportSetInputGraphicsImporter", (PyCFunction)Qt_GraphicsExportSetInputGraphicsImporter, 1,
     PyDoc_STR("(GraphicsExportComponent ci, GraphicsImportComponent grip) -> (ComponentResult _rv)")},
    {"GraphicsExportGetInputGraphicsImporter", (PyCFunction)Qt_GraphicsExportGetInputGraphicsImporter, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, GraphicsImportComponent grip)")},
    {"GraphicsExportSetInputPicture", (PyCFunction)Qt_GraphicsExportSetInputPicture, 1,
     PyDoc_STR("(GraphicsExportComponent ci, PicHandle picture) -> (ComponentResult _rv)")},
    {"GraphicsExportGetInputPicture", (PyCFunction)Qt_GraphicsExportGetInputPicture, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, PicHandle picture)")},
    {"GraphicsExportSetInputGWorld", (PyCFunction)Qt_GraphicsExportSetInputGWorld, 1,
     PyDoc_STR("(GraphicsExportComponent ci, GWorldPtr gworld) -> (ComponentResult _rv)")},
    {"GraphicsExportGetInputGWorld", (PyCFunction)Qt_GraphicsExportGetInputGWorld, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, GWorldPtr gworld)")},
    {"GraphicsExportSetInputPixmap", (PyCFunction)Qt_GraphicsExportSetInputPixmap, 1,
     PyDoc_STR("(GraphicsExportComponent ci, PixMapHandle pixmap) -> (ComponentResult _rv)")},
    {"GraphicsExportGetInputPixmap", (PyCFunction)Qt_GraphicsExportGetInputPixmap, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, PixMapHandle pixmap)")},
    {"GraphicsExportSetInputOffsetAndLimit", (PyCFunction)Qt_GraphicsExportSetInputOffsetAndLimit, 1,
     PyDoc_STR("(GraphicsExportComponent ci, unsigned long offset, unsigned long limit) -> (ComponentResult _rv)")},
    {"GraphicsExportGetInputOffsetAndLimit", (PyCFunction)Qt_GraphicsExportGetInputOffsetAndLimit, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long offset, unsigned long limit)")},
    {"GraphicsExportMayExporterReadInputData", (PyCFunction)Qt_GraphicsExportMayExporterReadInputData, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean mayReadInputData)")},
    {"GraphicsExportGetInputDataSize", (PyCFunction)Qt_GraphicsExportGetInputDataSize, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long size)")},
    {"GraphicsExportReadInputData", (PyCFunction)Qt_GraphicsExportReadInputData, 1,
     PyDoc_STR("(GraphicsExportComponent ci, void * dataPtr, unsigned long dataOffset, unsigned long dataSize) -> (ComponentResult _rv)")},
    {"GraphicsExportGetInputImageDescription", (PyCFunction)Qt_GraphicsExportGetInputImageDescription, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, ImageDescriptionHandle desc)")},
    {"GraphicsExportGetInputImageDimensions", (PyCFunction)Qt_GraphicsExportGetInputImageDimensions, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Rect dimensions)")},
    {"GraphicsExportGetInputImageDepth", (PyCFunction)Qt_GraphicsExportGetInputImageDepth, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, long inputDepth)")},
    {"GraphicsExportDrawInputImage", (PyCFunction)Qt_GraphicsExportDrawInputImage, 1,
     PyDoc_STR("(GraphicsExportComponent ci, CGrafPtr gw, GDHandle gd, Rect srcRect, Rect dstRect) -> (ComponentResult _rv)")},
    {"GraphicsExportSetOutputDataReference", (PyCFunction)Qt_GraphicsExportSetOutputDataReference, 1,
     PyDoc_STR("(GraphicsExportComponent ci, Handle dataRef, OSType dataRefType) -> (ComponentResult _rv)")},
    {"GraphicsExportGetOutputDataReference", (PyCFunction)Qt_GraphicsExportGetOutputDataReference, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType)")},
    {"GraphicsExportSetOutputFile", (PyCFunction)Qt_GraphicsExportSetOutputFile, 1,
     PyDoc_STR("(GraphicsExportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")},
    {"GraphicsExportGetOutputFile", (PyCFunction)Qt_GraphicsExportGetOutputFile, 1,
     PyDoc_STR("(GraphicsExportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")},
    {"GraphicsExportSetOutputHandle", (PyCFunction)Qt_GraphicsExportSetOutputHandle, 1,
     PyDoc_STR("(GraphicsExportComponent ci, Handle h) -> (ComponentResult _rv)")},
    {"GraphicsExportGetOutputHandle", (PyCFunction)Qt_GraphicsExportGetOutputHandle, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle h)")},
    {"GraphicsExportSetOutputOffsetAndMaxSize", (PyCFunction)Qt_GraphicsExportSetOutputOffsetAndMaxSize, 1,
     PyDoc_STR("(GraphicsExportComponent ci, unsigned long offset, unsigned long maxSize, Boolean truncateFile) -> (ComponentResult _rv)")},
    {"GraphicsExportGetOutputOffsetAndMaxSize", (PyCFunction)Qt_GraphicsExportGetOutputOffsetAndMaxSize, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long offset, unsigned long maxSize, Boolean truncateFile)")},
    {"GraphicsExportSetOutputFileTypeAndCreator", (PyCFunction)Qt_GraphicsExportSetOutputFileTypeAndCreator, 1,
     PyDoc_STR("(GraphicsExportComponent ci, OSType fileType, OSType fileCreator) -> (ComponentResult _rv)")},
    {"GraphicsExportGetOutputFileTypeAndCreator", (PyCFunction)Qt_GraphicsExportGetOutputFileTypeAndCreator, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, OSType fileType, OSType fileCreator)")},
    {"GraphicsExportSetOutputMark", (PyCFunction)Qt_GraphicsExportSetOutputMark, 1,
     PyDoc_STR("(GraphicsExportComponent ci, unsigned long mark) -> (ComponentResult _rv)")},
    {"GraphicsExportGetOutputMark", (PyCFunction)Qt_GraphicsExportGetOutputMark, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long mark)")},
    {"GraphicsExportReadOutputData", (PyCFunction)Qt_GraphicsExportReadOutputData, 1,
     PyDoc_STR("(GraphicsExportComponent ci, void * dataPtr, unsigned long dataOffset, unsigned long dataSize) -> (ComponentResult _rv)")},
    {"GraphicsExportSetThumbnailEnabled", (PyCFunction)Qt_GraphicsExportSetThumbnailEnabled, 1,
     PyDoc_STR("(GraphicsExportComponent ci, Boolean enableThumbnail, long maxThumbnailWidth, long maxThumbnailHeight) -> (ComponentResult _rv)")},
    {"GraphicsExportGetThumbnailEnabled", (PyCFunction)Qt_GraphicsExportGetThumbnailEnabled, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean thumbnailEnabled, long maxThumbnailWidth, long maxThumbnailHeight)")},
    {"GraphicsExportSetExifEnabled", (PyCFunction)Qt_GraphicsExportSetExifEnabled, 1,
     PyDoc_STR("(GraphicsExportComponent ci, Boolean enableExif) -> (ComponentResult _rv)")},
    {"GraphicsExportGetExifEnabled", (PyCFunction)Qt_GraphicsExportGetExifEnabled, 1,
     PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean exifEnabled)")},
    {"ImageTranscoderBeginSequence", (PyCFunction)Qt_ImageTranscoderBeginSequence, 1,
     PyDoc_STR("(ImageTranscoderComponent itc, ImageDescriptionHandle srcDesc, void * data, long dataSize) -> (ComponentResult _rv, ImageDescriptionHandle dstDesc)")},
    {"ImageTranscoderDisposeData", (PyCFunction)Qt_ImageTranscoderDisposeData, 1,
     PyDoc_STR("(ImageTranscoderComponent itc, void * dstData) -> (ComponentResult _rv)")},
    {"ImageTranscoderEndSequence", (PyCFunction)Qt_ImageTranscoderEndSequence, 1,
     PyDoc_STR("(ImageTranscoderComponent itc) -> (ComponentResult _rv)")},
    {"ClockGetTime", (PyCFunction)Qt_ClockGetTime, 1,
     PyDoc_STR("(ComponentInstance aClock) -> (ComponentResult _rv, TimeRecord out)")},
    {"ClockSetTimeBase", (PyCFunction)Qt_ClockSetTimeBase, 1,
     PyDoc_STR("(ComponentInstance aClock, TimeBase tb) -> (ComponentResult _rv)")},
    {"ClockGetRate", (PyCFunction)Qt_ClockGetRate, 1,
     PyDoc_STR("(ComponentInstance aClock) -> (ComponentResult _rv, Fixed rate)")},
    {"SCPositionRect", (PyCFunction)Qt_SCPositionRect, 1,
     PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv, Rect rp, Point where)")},
    {"SCPositionDialog", (PyCFunction)Qt_SCPositionDialog, 1,
     PyDoc_STR("(ComponentInstance ci, short id) -> (ComponentResult _rv, Point where)")},
    {"SCSetTestImagePictHandle", (PyCFunction)Qt_SCSetTestImagePictHandle, 1,
     PyDoc_STR("(ComponentInstance ci, PicHandle testPict, short testFlags) -> (ComponentResult _rv, Rect testRect)")},
    {"SCSetTestImagePictFile", (PyCFunction)Qt_SCSetTestImagePictFile, 1,
     PyDoc_STR("(ComponentInstance ci, short testFileRef, short testFlags) -> (ComponentResult _rv, Rect testRect)")},
    {"SCSetTestImagePixMap", (PyCFunction)Qt_SCSetTestImagePixMap, 1,
     PyDoc_STR("(ComponentInstance ci, PixMapHandle testPixMap, short testFlags) -> (ComponentResult _rv, Rect testRect)")},
    {"SCGetBestDeviceRect", (PyCFunction)Qt_SCGetBestDeviceRect, 1,
     PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv, Rect r)")},
    {"SCRequestImageSettings", (PyCFunction)Qt_SCRequestImageSettings, 1,
     PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv)")},
    {"SCCompressImage", (PyCFunction)Qt_SCCompressImage, 1,
     PyDoc_STR("(ComponentInstance ci, PixMapHandle src, Rect srcRect) -> (ComponentResult _rv, ImageDescriptionHandle desc, Handle data)")},
    {"SCCompressPicture", (PyCFunction)Qt_SCCompressPicture, 1,
     PyDoc_STR("(ComponentInstance ci, PicHandle srcPicture, PicHandle dstPicture) -> (ComponentResult _rv)")},
    {"SCCompressPictureFile", (PyCFunction)Qt_SCCompressPictureFile, 1,
     PyDoc_STR("(ComponentInstance ci, short srcRefNum, short dstRefNum) -> (ComponentResult _rv)")},
    {"SCRequestSequenceSettings", (PyCFunction)Qt_SCRequestSequenceSettings, 1,
     PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv)")},
    {"SCCompressSequenceBegin", (PyCFunction)Qt_SCCompressSequenceBegin, 1,
     PyDoc_STR("(ComponentInstance ci, PixMapHandle src, Rect srcRect) -> (ComponentResult _rv, ImageDescriptionHandle desc)")},
    {"SCCompressSequenceFrame", (PyCFunction)Qt_SCCompressSequenceFrame, 1,
     PyDoc_STR("(ComponentInstance ci, PixMapHandle src, Rect srcRect) -> (ComponentResult _rv, Handle data, long dataSize, short notSyncFlag)")},
    {"SCCompressSequenceEnd", (PyCFunction)Qt_SCCompressSequenceEnd, 1,
     PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv)")},
    {"SCDefaultPictHandleSettings", (PyCFunction)Qt_SCDefaultPictHandleSettings, 1,
     PyDoc_STR("(ComponentInstance ci, PicHandle srcPicture, short motion) -> (ComponentResult _rv)")},
    {"SCDefaultPictFileSettings", (PyCFunction)Qt_SCDefaultPictFileSettings, 1,
     PyDoc_STR("(ComponentInstance ci, short srcRef, short motion) -> (ComponentResult _rv)")},
    {"SCDefaultPixMapSettings", (PyCFunction)Qt_SCDefaultPixMapSettings, 1,
     PyDoc_STR("(ComponentInstance ci, PixMapHandle src, short motion) -> (ComponentResult _rv)")},
    {"SCGetInfo", (PyCFunction)Qt_SCGetInfo, 1,
     PyDoc_STR("(ComponentInstance ci, OSType infoType, void * info) -> (ComponentResult _rv)")},
    {"SCSetInfo", (PyCFunction)Qt_SCSetInfo, 1,
     PyDoc_STR("(ComponentInstance ci, OSType infoType, void * info) -> (ComponentResult _rv)")},
    {"SCSetCompressFlags", (PyCFunction)Qt_SCSetCompressFlags, 1,
     PyDoc_STR("(ComponentInstance ci, long flags) -> (ComponentResult _rv)")},
    {"SCGetCompressFlags", (PyCFunction)Qt_SCGetCompressFlags, 1,
     PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv, long flags)")},
    {"SCGetSettingsAsText", (PyCFunction)Qt_SCGetSettingsAsText, 1,
     PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv, Handle text)")},
    {"SCAsyncIdle", (PyCFunction)Qt_SCAsyncIdle, 1,
     PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv)")},
    {"TweenerReset", (PyCFunction)Qt_TweenerReset, 1,
     PyDoc_STR("(TweenerComponent tc) -> (ComponentResult _rv)")},
    {"TCGetSourceRef", (PyCFunction)Qt_TCGetSourceRef, 1,
     PyDoc_STR("(MediaHandler mh, TimeCodeDescriptionHandle tcdH) -> (HandlerError _rv, UserData srefH)")},
    {"TCSetSourceRef", (PyCFunction)Qt_TCSetSourceRef, 1,
     PyDoc_STR("(MediaHandler mh, TimeCodeDescriptionHandle tcdH, UserData srefH) -> (HandlerError _rv)")},
    {"TCSetTimeCodeFlags", (PyCFunction)Qt_TCSetTimeCodeFlags, 1,
     PyDoc_STR("(MediaHandler mh, long flags, long flagsMask) -> (HandlerError _rv)")},
    {"TCGetTimeCodeFlags", (PyCFunction)Qt_TCGetTimeCodeFlags, 1,
     PyDoc_STR("(MediaHandler mh) -> (HandlerError _rv, long flags)")},
    {"MovieImportHandle", (PyCFunction)Qt_MovieImportHandle, 1,
     PyDoc_STR("(MovieImportComponent ci, Handle dataH, Movie theMovie, Track targetTrack, TimeValue atTime, long inFlags) -> (ComponentResult _rv, Track usedTrack, TimeValue addedDuration, long outFlags)")},
    {"MovieImportFile", (PyCFunction)Qt_MovieImportFile, 1,
     PyDoc_STR("(MovieImportComponent ci, FSSpec theFile, Movie theMovie, Track targetTrack, TimeValue atTime, long inFlags) -> (ComponentResult _rv, Track usedTrack, TimeValue addedDuration, long outFlags)")},
    {"MovieImportSetSampleDuration", (PyCFunction)Qt_MovieImportSetSampleDuration, 1,
     PyDoc_STR("(MovieImportComponent ci, TimeValue duration, TimeScale scale) -> (ComponentResult _rv)")},
    {"MovieImportSetSampleDescription", (PyCFunction)Qt_MovieImportSetSampleDescription, 1,
     PyDoc_STR("(MovieImportComponent ci, SampleDescriptionHandle desc, OSType mediaType) -> (ComponentResult _rv)")},
    {"MovieImportSetMediaFile", (PyCFunction)Qt_MovieImportSetMediaFile, 1,
     PyDoc_STR("(MovieImportComponent ci, AliasHandle alias) -> (ComponentResult _rv)")},
    {"MovieImportSetDimensions", (PyCFunction)Qt_MovieImportSetDimensions, 1,
     PyDoc_STR("(MovieImportComponent ci, Fixed width, Fixed height) -> (ComponentResult _rv)")},
    {"MovieImportSetChunkSize", (PyCFunction)Qt_MovieImportSetChunkSize, 1,
     PyDoc_STR("(MovieImportComponent ci, long chunkSize) -> (ComponentResult _rv)")},
    {"MovieImportSetAuxiliaryData", (PyCFunction)Qt_MovieImportSetAuxiliaryData, 1,
     PyDoc_STR("(MovieImportComponent ci, Handle data, OSType handleType) -> (ComponentResult _rv)")},
    {"MovieImportSetFromScrap", (PyCFunction)Qt_MovieImportSetFromScrap, 1,
     PyDoc_STR("(MovieImportComponent ci, Boolean fromScrap) -> (ComponentResult _rv)")},
    {"MovieImportDoUserDialog", (PyCFunction)Qt_MovieImportDoUserDialog, 1,
     PyDoc_STR("(MovieImportComponent ci, FSSpec theFile, Handle theData) -> (ComponentResult _rv, Boolean canceled)")},
    {"MovieImportSetDuration", (PyCFunction)Qt_MovieImportSetDuration, 1,
     PyDoc_STR("(MovieImportComponent ci, TimeValue duration) -> (ComponentResult _rv)")},
    {"MovieImportGetAuxiliaryDataType", (PyCFunction)Qt_MovieImportGetAuxiliaryDataType, 1,
     PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, OSType auxType)")},
    {"MovieImportValidate", (PyCFunction)Qt_MovieImportValidate, 1,
     PyDoc_STR("(MovieImportComponent ci, FSSpec theFile, Handle theData) -> (ComponentResult _rv, Boolean valid)")},
    {"MovieImportGetFileType", (PyCFunction)Qt_MovieImportGetFileType, 1,
     PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, OSType fileType)")},
    {"MovieImportDataRef", (PyCFunction)Qt_MovieImportDataRef, 1,
     PyDoc_STR("(MovieImportComponent ci, Handle dataRef, OSType dataRefType, Movie theMovie, Track targetTrack, TimeValue atTime, long inFlags) -> (ComponentResult _rv, Track usedTrack, TimeValue addedDuration, long outFlags)")},
    {"MovieImportGetSampleDescription", (PyCFunction)Qt_MovieImportGetSampleDescription, 1,
     PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, SampleDescriptionHandle desc, OSType mediaType)")},
    {"MovieImportSetOffsetAndLimit", (PyCFunction)Qt_MovieImportSetOffsetAndLimit, 1,
     PyDoc_STR("(MovieImportComponent ci, unsigned long offset, unsigned long limit) -> (ComponentResult _rv)")},
    {"MovieImportSetOffsetAndLimit64", (PyCFunction)Qt_MovieImportSetOffsetAndLimit64, 1,
     PyDoc_STR("(MovieImportComponent ci, wide offset, wide limit) -> (ComponentResult _rv)")},
    {"MovieImportIdle", (PyCFunction)Qt_MovieImportIdle, 1,
     PyDoc_STR("(MovieImportComponent ci, long inFlags) -> (ComponentResult _rv, long outFlags)")},
    {"MovieImportValidateDataRef", (PyCFunction)Qt_MovieImportValidateDataRef, 1,
     PyDoc_STR("(MovieImportComponent ci, Handle dataRef, OSType dataRefType) -> (ComponentResult _rv, UInt8 valid)")},
    {"MovieImportGetLoadState", (PyCFunction)Qt_MovieImportGetLoadState, 1,
     PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, long importerLoadState)")},
    {"MovieImportGetMaxLoadedTime", (PyCFunction)Qt_MovieImportGetMaxLoadedTime, 1,
     PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, TimeValue time)")},
    {"MovieImportEstimateCompletionTime", (PyCFunction)Qt_MovieImportEstimateCompletionTime, 1,
     PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, TimeRecord time)")},
    {"MovieImportSetDontBlock", (PyCFunction)Qt_MovieImportSetDontBlock, 1,
     PyDoc_STR("(MovieImportComponent ci, Boolean dontBlock) -> (ComponentResult _rv)")},
    {"MovieImportGetDontBlock", (PyCFunction)Qt_MovieImportGetDontBlock, 1,
     PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, Boolean willBlock)")},
    {"MovieImportSetIdleManager", (PyCFunction)Qt_MovieImportSetIdleManager, 1,
     PyDoc_STR("(MovieImportComponent ci, IdleManager im) -> (ComponentResult _rv)")},
    {"MovieImportSetNewMovieFlags", (PyCFunction)Qt_MovieImportSetNewMovieFlags, 1,
     PyDoc_STR("(MovieImportComponent ci, long newMovieFlags) -> (ComponentResult _rv)")},
    {"MovieImportGetDestinationMediaType", (PyCFunction)Qt_MovieImportGetDestinationMediaType, 1,
     PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, OSType mediaType)")},
    {"MovieExportToHandle", (PyCFunction)Qt_MovieExportToHandle, 1,
     PyDoc_STR("(MovieExportComponent ci, Handle dataH, Movie theMovie, Track onlyThisTrack, TimeValue startTime, TimeValue duration) -> (ComponentResult _rv)")},
    {"MovieExportToFile", (PyCFunction)Qt_MovieExportToFile, 1,
     PyDoc_STR("(MovieExportComponent ci, FSSpec theFile, Movie theMovie, Track onlyThisTrack, TimeValue startTime, TimeValue duration) -> (ComponentResult _rv)")},
    {"MovieExportGetAuxiliaryData", (PyCFunction)Qt_MovieExportGetAuxiliaryData, 1,
     PyDoc_STR("(MovieExportComponent ci, Handle dataH) -> (ComponentResult _rv, OSType handleType)")},
    {"MovieExportSetSampleDescription", (PyCFunction)Qt_MovieExportSetSampleDescription, 1,
     PyDoc_STR("(MovieExportComponent ci, SampleDescriptionHandle desc, OSType mediaType) -> (ComponentResult _rv)")},
    {"MovieExportDoUserDialog", (PyCFunction)Qt_MovieExportDoUserDialog, 1,
     PyDoc_STR("(MovieExportComponent ci, Movie theMovie, Track onlyThisTrack, TimeValue startTime, TimeValue duration) -> (ComponentResult _rv, Boolean canceled)")},
    {"MovieExportGetCreatorType", (PyCFunction)Qt_MovieExportGetCreatorType, 1,
     PyDoc_STR("(MovieExportComponent ci) -> (ComponentResult _rv, OSType creator)")},
    {"MovieExportToDataRef", (PyCFunction)Qt_MovieExportToDataRef, 1,
     PyDoc_STR("(MovieExportComponent ci, Handle dataRef, OSType dataRefType, Movie theMovie, Track onlyThisTrack, TimeValue startTime, TimeValue duration) -> (ComponentResult _rv)")},
    {"MovieExportFromProceduresToDataRef", (PyCFunction)Qt_MovieExportFromProceduresToDataRef, 1,
     PyDoc_STR("(MovieExportComponent ci, Handle dataRef, OSType dataRefType) -> (ComponentResult _rv)")},
    {"MovieExportValidate", (PyCFunction)Qt_MovieExportValidate, 1,
     PyDoc_STR("(MovieExportComponent ci, Movie theMovie, Track onlyThisTrack) -> (ComponentResult _rv, Boolean valid)")},
    {"MovieExportGetFileNameExtension", (PyCFunction)Qt_MovieExportGetFileNameExtension, 1,
     PyDoc_STR("(MovieExportComponent ci) -> (ComponentResult _rv, OSType extension)")},
    {"MovieExportGetShortFileTypeString", (PyCFunction)Qt_MovieExportGetShortFileTypeString, 1,
     PyDoc_STR("(MovieExportComponent ci, Str255 typeString) -> (ComponentResult _rv)")},
    {"MovieExportGetSourceMediaType", (PyCFunction)Qt_MovieExportGetSourceMediaType, 1,
     PyDoc_STR("(MovieExportComponent ci) -> (ComponentResult _rv, OSType mediaType)")},
    {"TextExportGetTimeFraction", (PyCFunction)Qt_TextExportGetTimeFraction, 1,
     PyDoc_STR("(TextExportComponent ci) -> (ComponentResult _rv, long movieTimeFraction)")},
    {"TextExportSetTimeFraction", (PyCFunction)Qt_TextExportSetTimeFraction, 1,
     PyDoc_STR("(TextExportComponent ci, long movieTimeFraction) -> (ComponentResult _rv)")},
    {"TextExportGetSettings", (PyCFunction)Qt_TextExportGetSettings, 1,
     PyDoc_STR("(TextExportComponent ci) -> (ComponentResult _rv, long setting)")},
    {"TextExportSetSettings", (PyCFunction)Qt_TextExportSetSettings, 1,
     PyDoc_STR("(TextExportComponent ci, long setting) -> (ComponentResult _rv)")},
    {"MIDIImportGetSettings", (PyCFunction)Qt_MIDIImportGetSettings, 1,
     PyDoc_STR("(TextExportComponent ci) -> (ComponentResult _rv, long setting)")},
    {"MIDIImportSetSettings", (PyCFunction)Qt_MIDIImportSetSettings, 1,
     PyDoc_STR("(TextExportComponent ci, long setting) -> (ComponentResult _rv)")},
    {"GraphicsImageImportSetSequenceEnabled", (PyCFunction)Qt_GraphicsImageImportSetSequenceEnabled, 1,
     PyDoc_STR("(GraphicImageMovieImportComponent ci, Boolean enable) -> (ComponentResult _rv)")},
    {"GraphicsImageImportGetSequenceEnabled", (PyCFunction)Qt_GraphicsImageImportGetSequenceEnabled, 1,
     PyDoc_STR("(GraphicImageMovieImportComponent ci) -> (ComponentResult _rv, Boolean enable)")},
    {"PreviewShowData", (PyCFunction)Qt_PreviewShowData, 1,
     PyDoc_STR("(pnotComponent p, OSType dataType, Handle data, Rect inHere) -> (ComponentResult _rv)")},
    {"PreviewMakePreviewReference", (PyCFunction)Qt_PreviewMakePreviewReference, 1,
     PyDoc_STR("(pnotComponent p, FSSpec sourceFile) -> (ComponentResult _rv, OSType previewType, short resID)")},
    {"PreviewEvent", (PyCFunction)Qt_PreviewEvent, 1,
     PyDoc_STR("(pnotComponent p) -> (ComponentResult _rv, EventRecord e, Boolean handledEvent)")},
    {"DataCodecDecompress", (PyCFunction)Qt_DataCodecDecompress, 1,
     PyDoc_STR("(DataCodecComponent dc, void * srcData, UInt32 srcSize, void * dstData, UInt32 dstBufferSize) -> (ComponentResult _rv)")},
    {"DataCodecGetCompressBufferSize", (PyCFunction)Qt_DataCodecGetCompressBufferSize, 1,
     PyDoc_STR("(DataCodecComponent dc, UInt32 srcSize) -> (ComponentResult _rv, UInt32 dstSize)")},
    {"DataCodecCompress", (PyCFunction)Qt_DataCodecCompress, 1,
     PyDoc_STR("(DataCodecComponent dc, void * srcData, UInt32 srcSize, void * dstData, UInt32 dstBufferSize) -> (ComponentResult _rv, UInt32 actualDstSize, UInt32 decompressSlop)")},
    {"DataCodecBeginInterruptSafe", (PyCFunction)Qt_DataCodecBeginInterruptSafe, 1,
     PyDoc_STR("(DataCodecComponent dc, unsigned long maxSrcSize) -> (ComponentResult _rv)")},
    {"DataCodecEndInterruptSafe", (PyCFunction)Qt_DataCodecEndInterruptSafe, 1,
     PyDoc_STR("(DataCodecComponent dc) -> (ComponentResult _rv)")},
    {"DataHGetData", (PyCFunction)Qt_DataHGetData, 1,
     PyDoc_STR("(DataHandler dh, Handle h, long hOffset, long offset, long size) -> (ComponentResult _rv)")},
    {"DataHPutData", (PyCFunction)Qt_DataHPutData, 1,
     PyDoc_STR("(DataHandler dh, Handle h, long hOffset, long size) -> (ComponentResult _rv, long offset)")},
    {"DataHFlushData", (PyCFunction)Qt_DataHFlushData, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
    {"DataHOpenForWrite", (PyCFunction)Qt_DataHOpenForWrite, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
    {"DataHCloseForWrite", (PyCFunction)Qt_DataHCloseForWrite, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
    {"DataHOpenForRead", (PyCFunction)Qt_DataHOpenForRead, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
    {"DataHCloseForRead", (PyCFunction)Qt_DataHCloseForRead, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
    {"DataHSetDataRef", (PyCFunction)Qt_DataHSetDataRef, 1,
     PyDoc_STR("(DataHandler dh, Handle dataRef) -> (ComponentResult _rv)")},
    {"DataHGetDataRef", (PyCFunction)Qt_DataHGetDataRef, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Handle dataRef)")},
    {"DataHCompareDataRef", (PyCFunction)Qt_DataHCompareDataRef, 1,
     PyDoc_STR("(DataHandler dh, Handle dataRef) -> (ComponentResult _rv, Boolean equal)")},
    {"DataHTask", (PyCFunction)Qt_DataHTask, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
    {"DataHFinishData", (PyCFunction)Qt_DataHFinishData, 1,
     PyDoc_STR("(DataHandler dh, Ptr PlaceToPutDataPtr, Boolean Cancel) -> (ComponentResult _rv)")},
    {"DataHFlushCache", (PyCFunction)Qt_DataHFlushCache, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
    {"DataHResolveDataRef", (PyCFunction)Qt_DataHResolveDataRef, 1,
     PyDoc_STR("(DataHandler dh, Handle theDataRef, Boolean userInterfaceAllowed) -> (ComponentResult _rv, Boolean wasChanged)")},
    {"DataHGetFileSize", (PyCFunction)Qt_DataHGetFileSize, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long fileSize)")},
    {"DataHCanUseDataRef", (PyCFunction)Qt_DataHCanUseDataRef, 1,
     PyDoc_STR("(DataHandler dh, Handle dataRef) -> (ComponentResult _rv, long useFlags)")},
    {"DataHPreextend", (PyCFunction)Qt_DataHPreextend, 1,
     PyDoc_STR("(DataHandler dh, unsigned long maxToAdd) -> (ComponentResult _rv, unsigned long spaceAdded)")},
    {"DataHSetFileSize", (PyCFunction)Qt_DataHSetFileSize, 1,
     PyDoc_STR("(DataHandler dh, long fileSize) -> (ComponentResult _rv)")},
    {"DataHGetFreeSpace", (PyCFunction)Qt_DataHGetFreeSpace, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, unsigned long freeSize)")},
    {"DataHCreateFile", (PyCFunction)Qt_DataHCreateFile, 1,
     PyDoc_STR("(DataHandler dh, OSType creator, Boolean deleteExisting) -> (ComponentResult _rv)")},
    {"DataHGetPreferredBlockSize", (PyCFunction)Qt_DataHGetPreferredBlockSize, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long blockSize)")},
    {"DataHGetDeviceIndex", (PyCFunction)Qt_DataHGetDeviceIndex, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long deviceIndex)")},
    {"DataHIsStreamingDataHandler", (PyCFunction)Qt_DataHIsStreamingDataHandler, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Boolean yes)")},
    {"DataHGetDataInBuffer", (PyCFunction)Qt_DataHGetDataInBuffer, 1,
     PyDoc_STR("(DataHandler dh, long startOffset) -> (ComponentResult _rv, long size)")},
    {"DataHGetScheduleAheadTime", (PyCFunction)Qt_DataHGetScheduleAheadTime, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long millisecs)")},
    {"DataHSetCacheSizeLimit", (PyCFunction)Qt_DataHSetCacheSizeLimit, 1,
     PyDoc_STR("(DataHandler dh, Size cacheSizeLimit) -> (ComponentResult _rv)")},
    {"DataHGetCacheSizeLimit", (PyCFunction)Qt_DataHGetCacheSizeLimit, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Size cacheSizeLimit)")},
    {"DataHGetMovie", (PyCFunction)Qt_DataHGetMovie, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Movie theMovie, short id)")},
    {"DataHAddMovie", (PyCFunction)Qt_DataHAddMovie, 1,
     PyDoc_STR("(DataHandler dh, Movie theMovie) -> (ComponentResult _rv, short id)")},
    {"DataHUpdateMovie", (PyCFunction)Qt_DataHUpdateMovie, 1,
     PyDoc_STR("(DataHandler dh, Movie theMovie, short id) -> (ComponentResult _rv)")},
    {"DataHDoesBuffer", (PyCFunction)Qt_DataHDoesBuffer, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Boolean buffersReads, Boolean buffersWrites)")},
    {"DataHGetFileName", (PyCFunction)Qt_DataHGetFileName, 1,
     PyDoc_STR("(DataHandler dh, Str255 str) -> (ComponentResult _rv)")},
    {"DataHGetAvailableFileSize", (PyCFunction)Qt_DataHGetAvailableFileSize, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long fileSize)")},
    {"DataHGetMacOSFileType", (PyCFunction)Qt_DataHGetMacOSFileType, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, OSType fileType)")},
    {"DataHGetMIMEType", (PyCFunction)Qt_DataHGetMIMEType, 1,
     PyDoc_STR("(DataHandler dh, Str255 mimeType) -> (ComponentResult _rv)")},
    {"DataHSetDataRefWithAnchor", (PyCFunction)Qt_DataHSetDataRefWithAnchor, 1,
     PyDoc_STR("(DataHandler dh, Handle anchorDataRef, OSType dataRefType, Handle dataRef) -> (ComponentResult _rv)")},
    {"DataHGetDataRefWithAnchor", (PyCFunction)Qt_DataHGetDataRefWithAnchor, 1,
     PyDoc_STR("(DataHandler dh, Handle anchorDataRef, OSType dataRefType) -> (ComponentResult _rv, Handle dataRef)")},
    {"DataHSetMacOSFileType", (PyCFunction)Qt_DataHSetMacOSFileType, 1,
     PyDoc_STR("(DataHandler dh, OSType fileType) -> (ComponentResult _rv)")},
    {"DataHSetTimeBase", (PyCFunction)Qt_DataHSetTimeBase, 1,
     PyDoc_STR("(DataHandler dh, TimeBase tb) -> (ComponentResult _rv)")},
    {"DataHGetInfoFlags", (PyCFunction)Qt_DataHGetInfoFlags, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, UInt32 flags)")},
    {"DataHGetFileSize64", (PyCFunction)Qt_DataHGetFileSize64, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, wide fileSize)")},
    {"DataHPreextend64", (PyCFunction)Qt_DataHPreextend64, 1,
     PyDoc_STR("(DataHandler dh, wide maxToAdd) -> (ComponentResult _rv, wide spaceAdded)")},
    {"DataHSetFileSize64", (PyCFunction)Qt_DataHSetFileSize64, 1,
     PyDoc_STR("(DataHandler dh, wide fileSize) -> (ComponentResult _rv)")},
    {"DataHGetFreeSpace64", (PyCFunction)Qt_DataHGetFreeSpace64, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, wide freeSize)")},
    {"DataHAppend64", (PyCFunction)Qt_DataHAppend64, 1,
     PyDoc_STR("(DataHandler dh, void * data, unsigned long size) -> (ComponentResult _rv, wide fileOffset)")},
    {"DataHPollRead", (PyCFunction)Qt_DataHPollRead, 1,
     PyDoc_STR("(DataHandler dh, void * dataPtr) -> (ComponentResult _rv, UInt32 dataSizeSoFar)")},
    {"DataHGetDataAvailability", (PyCFunction)Qt_DataHGetDataAvailability, 1,
     PyDoc_STR("(DataHandler dh, long offset, long len) -> (ComponentResult _rv, long missing_offset, long missing_len)")},
    {"DataHGetDataRefAsType", (PyCFunction)Qt_DataHGetDataRefAsType, 1,
     PyDoc_STR("(DataHandler dh, OSType requestedType) -> (ComponentResult _rv, Handle dataRef)")},
    {"DataHSetDataRefExtension", (PyCFunction)Qt_DataHSetDataRefExtension, 1,
     PyDoc_STR("(DataHandler dh, Handle extension, OSType idType) -> (ComponentResult _rv)")},
    {"DataHGetDataRefExtension", (PyCFunction)Qt_DataHGetDataRefExtension, 1,
     PyDoc_STR("(DataHandler dh, OSType idType) -> (ComponentResult _rv, Handle extension)")},
    {"DataHGetMovieWithFlags", (PyCFunction)Qt_DataHGetMovieWithFlags, 1,
     PyDoc_STR("(DataHandler dh, short flags) -> (ComponentResult _rv, Movie theMovie, short id)")},
    {"DataHGetFileTypeOrdering", (PyCFunction)Qt_DataHGetFileTypeOrdering, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, DataHFileTypeOrderingHandle orderingListHandle)")},
    {"DataHCreateFileWithFlags", (PyCFunction)Qt_DataHCreateFileWithFlags, 1,
     PyDoc_STR("(DataHandler dh, OSType creator, Boolean deleteExisting, UInt32 flags) -> (ComponentResult _rv)")},
    {"DataHGetInfo", (PyCFunction)Qt_DataHGetInfo, 1,
     PyDoc_STR("(DataHandler dh, OSType what, void * info) -> (ComponentResult _rv)")},
    {"DataHSetIdleManager", (PyCFunction)Qt_DataHSetIdleManager, 1,
     PyDoc_STR("(DataHandler dh, IdleManager im) -> (ComponentResult _rv)")},
    {"DataHDeleteFile", (PyCFunction)Qt_DataHDeleteFile, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
    {"DataHSetMovieUsageFlags", (PyCFunction)Qt_DataHSetMovieUsageFlags, 1,
     PyDoc_STR("(DataHandler dh, long flags) -> (ComponentResult _rv)")},
    {"DataHUseTemporaryDataRef", (PyCFunction)Qt_DataHUseTemporaryDataRef, 1,
     PyDoc_STR("(DataHandler dh, long inFlags) -> (ComponentResult _rv)")},
    {"DataHGetTemporaryDataRefCapabilities", (PyCFunction)Qt_DataHGetTemporaryDataRefCapabilities, 1,
     PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long outUnderstoodFlags)")},
    {"DataHRenameFile", (PyCFunction)Qt_DataHRenameFile, 1,
     PyDoc_STR("(DataHandler dh, Handle newDataRef) -> (ComponentResult _rv)")},
    {"DataHPlaybackHints", (PyCFunction)Qt_DataHPlaybackHints, 1,
     PyDoc_STR("(DataHandler dh, long flags, unsigned long minFileOffset, unsigned long maxFileOffset, long bytesPerSecond) -> (ComponentResult _rv)")},
    {"DataHPlaybackHints64", (PyCFunction)Qt_DataHPlaybackHints64, 1,
     PyDoc_STR("(DataHandler dh, long flags, wide minFileOffset, wide maxFileOffset, long bytesPerSecond) -> (ComponentResult _rv)")},
    {"DataHGetDataRate", (PyCFunction)Qt_DataHGetDataRate, 1,
     PyDoc_STR("(DataHandler dh, long flags) -> (ComponentResult _rv, long bytesPerSecond)")},
    {"DataHSetTimeHints", (PyCFunction)Qt_DataHSetTimeHints, 1,
     PyDoc_STR("(DataHandler dh, long flags, long bandwidthPriority, TimeScale scale, TimeValue minTime, TimeValue maxTime) -> (ComponentResult _rv)")},
    {"VDGetMaxSrcRect", (PyCFunction)Qt_VDGetMaxSrcRect, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, short inputStd) -> (ComponentResult _rv, Rect maxSrcRect)")},
    {"VDGetActiveSrcRect", (PyCFunction)Qt_VDGetActiveSrcRect, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, short inputStd) -> (ComponentResult _rv, Rect activeSrcRect)")},
    {"VDSetDigitizerRect", (PyCFunction)Qt_VDSetDigitizerRect, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, Rect digitizerRect)")},
    {"VDGetDigitizerRect", (PyCFunction)Qt_VDGetDigitizerRect, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, Rect digitizerRect)")},
    {"VDGetVBlankRect", (PyCFunction)Qt_VDGetVBlankRect, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, short inputStd) -> (ComponentResult _rv, Rect vBlankRect)")},
    {"VDGetMaskPixMap", (PyCFunction)Qt_VDGetMaskPixMap, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, PixMapHandle maskPixMap) -> (ComponentResult _rv)")},
    {"VDUseThisCLUT", (PyCFunction)Qt_VDUseThisCLUT, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, CTabHandle colorTableHandle) -> (ComponentResult _rv)")},
    {"VDSetInputGammaValue", (PyCFunction)Qt_VDSetInputGammaValue, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, Fixed channel1, Fixed channel2, Fixed channel3) -> (ComponentResult _rv)")},
    {"VDGetInputGammaValue", (PyCFunction)Qt_VDGetInputGammaValue, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, Fixed channel1, Fixed channel2, Fixed channel3)")},
    {"VDSetBrightness", (PyCFunction)Qt_VDSetBrightness, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short brightness)")},
    {"VDGetBrightness", (PyCFunction)Qt_VDGetBrightness, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short brightness)")},
    {"VDSetContrast", (PyCFunction)Qt_VDSetContrast, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short contrast)")},
    {"VDSetHue", (PyCFunction)Qt_VDSetHue, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short hue)")},
    {"VDSetSharpness", (PyCFunction)Qt_VDSetSharpness, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short sharpness)")},
    {"VDSetSaturation", (PyCFunction)Qt_VDSetSaturation, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short saturation)")},
    {"VDGetContrast", (PyCFunction)Qt_VDGetContrast, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short contrast)")},
    {"VDGetHue", (PyCFunction)Qt_VDGetHue, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short hue)")},
    {"VDGetSharpness", (PyCFunction)Qt_VDGetSharpness, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short sharpness)")},
    {"VDGetSaturation", (PyCFunction)Qt_VDGetSaturation, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short saturation)")},
    {"VDGrabOneFrame", (PyCFunction)Qt_VDGrabOneFrame, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv)")},
    {"VDGetMaxAuxBuffer", (PyCFunction)Qt_VDGetMaxAuxBuffer, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, PixMapHandle pm, Rect r)")},
    {"VDGetCurrentFlags", (PyCFunction)Qt_VDGetCurrentFlags, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long inputCurrentFlag, long outputCurrentFlag)")},
    {"VDSetKeyColor", (PyCFunction)Qt_VDSetKeyColor, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, long index) -> (ComponentResult _rv)")},
    {"VDGetKeyColor", (PyCFunction)Qt_VDGetKeyColor, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long index)")},
    {"VDAddKeyColor", (PyCFunction)Qt_VDAddKeyColor, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long index)")},
    {"VDGetNextKeyColor", (PyCFunction)Qt_VDGetNextKeyColor, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, long index) -> (ComponentResult _rv)")},
    {"VDSetKeyColorRange", (PyCFunction)Qt_VDSetKeyColorRange, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, RGBColor minRGB, RGBColor maxRGB)")},
    {"VDGetKeyColorRange", (PyCFunction)Qt_VDGetKeyColorRange, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, RGBColor minRGB, RGBColor maxRGB)")},
    {"VDSetInputColorSpaceMode", (PyCFunction)Qt_VDSetInputColorSpaceMode, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, short colorSpaceMode) -> (ComponentResult _rv)")},
    {"VDGetInputColorSpaceMode", (PyCFunction)Qt_VDGetInputColorSpaceMode, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short colorSpaceMode)")},
    {"VDSetClipState", (PyCFunction)Qt_VDSetClipState, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, short clipEnable) -> (ComponentResult _rv)")},
    {"VDGetClipState", (PyCFunction)Qt_VDGetClipState, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short clipEnable)")},
    {"VDSetClipRgn", (PyCFunction)Qt_VDSetClipRgn, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, RgnHandle clipRegion) -> (ComponentResult _rv)")},
    {"VDClearClipRgn", (PyCFunction)Qt_VDClearClipRgn, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, RgnHandle clipRegion) -> (ComponentResult _rv)")},
    {"VDGetCLUTInUse", (PyCFunction)Qt_VDGetCLUTInUse, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, CTabHandle colorTableHandle)")},
    {"VDSetPLLFilterType", (PyCFunction)Qt_VDSetPLLFilterType, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, short pllType) -> (ComponentResult _rv)")},
    {"VDGetPLLFilterType", (PyCFunction)Qt_VDGetPLLFilterType, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short pllType)")},
    {"VDGetMaskandValue", (PyCFunction)Qt_VDGetMaskandValue, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, unsigned short blendLevel) -> (ComponentResult _rv, long mask, long value)")},
    {"VDSetMasterBlendLevel", (PyCFunction)Qt_VDSetMasterBlendLevel, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short blendLevel)")},
    {"VDSetPlayThruOnOff", (PyCFunction)Qt_VDSetPlayThruOnOff, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, short state) -> (ComponentResult _rv)")},
    {"VDSetFieldPreference", (PyCFunction)Qt_VDSetFieldPreference, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, short fieldFlag) -> (ComponentResult _rv)")},
    {"VDGetFieldPreference", (PyCFunction)Qt_VDGetFieldPreference, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short fieldFlag)")},
    {"VDPreflightGlobalRect", (PyCFunction)Qt_VDPreflightGlobalRect, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, GrafPtr theWindow) -> (ComponentResult _rv, Rect globalRect)")},
    {"VDSetPlayThruGlobalRect", (PyCFunction)Qt_VDSetPlayThruGlobalRect, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, GrafPtr theWindow) -> (ComponentResult _rv, Rect globalRect)")},
    {"VDSetBlackLevelValue", (PyCFunction)Qt_VDSetBlackLevelValue, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short blackLevel)")},
    {"VDGetBlackLevelValue", (PyCFunction)Qt_VDGetBlackLevelValue, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short blackLevel)")},
    {"VDSetWhiteLevelValue", (PyCFunction)Qt_VDSetWhiteLevelValue, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short whiteLevel)")},
    {"VDGetWhiteLevelValue", (PyCFunction)Qt_VDGetWhiteLevelValue, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short whiteLevel)")},
    {"VDGetVideoDefaults", (PyCFunction)Qt_VDGetVideoDefaults, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short blackLevel, unsigned short whiteLevel, unsigned short brightness, unsigned short hue, unsigned short saturation, unsigned short contrast, unsigned short sharpness)")},
    {"VDGetNumberOfInputs", (PyCFunction)Qt_VDGetNumberOfInputs, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short inputs)")},
    {"VDGetInputFormat", (PyCFunction)Qt_VDGetInputFormat, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, short input) -> (ComponentResult _rv, short format)")},
    {"VDSetInput", (PyCFunction)Qt_VDSetInput, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, short input) -> (ComponentResult _rv)")},
    {"VDGetInput", (PyCFunction)Qt_VDGetInput, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short input)")},
    {"VDSetInputStandard", (PyCFunction)Qt_VDSetInputStandard, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, short inputStandard) -> (ComponentResult _rv)")},
    {"VDSetupBuffers", (PyCFunction)Qt_VDSetupBuffers, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, VdigBufferRecListHandle bufferList) -> (ComponentResult _rv)")},
    {"VDGrabOneFrameAsync", (PyCFunction)Qt_VDGrabOneFrameAsync, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, short buffer) -> (ComponentResult _rv)")},
    {"VDDone", (PyCFunction)Qt_VDDone, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, short buffer) -> (ComponentResult _rv)")},
    {"VDSetCompression", (PyCFunction)Qt_VDSetCompression, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, OSType compressType, short depth, CodecQ spatialQuality, CodecQ temporalQuality, long keyFrameRate) -> (ComponentResult _rv, Rect bounds)")},
    {"VDCompressOneFrameAsync", (PyCFunction)Qt_VDCompressOneFrameAsync, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv)")},
    {"VDGetImageDescription", (PyCFunction)Qt_VDGetImageDescription, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, ImageDescriptionHandle desc) -> (ComponentResult _rv)")},
    {"VDResetCompressSequence", (PyCFunction)Qt_VDResetCompressSequence, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv)")},
    {"VDSetCompressionOnOff", (PyCFunction)Qt_VDSetCompressionOnOff, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, Boolean state) -> (ComponentResult _rv)")},
    {"VDGetCompressionTypes", (PyCFunction)Qt_VDGetCompressionTypes, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, VDCompressionListHandle h) -> (ComponentResult _rv)")},
    {"VDSetTimeBase", (PyCFunction)Qt_VDSetTimeBase, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, TimeBase t) -> (ComponentResult _rv)")},
    {"VDSetFrameRate", (PyCFunction)Qt_VDSetFrameRate, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, Fixed framesPerSecond) -> (ComponentResult _rv)")},
    {"VDGetDataRate", (PyCFunction)Qt_VDGetDataRate, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long milliSecPerFrame, Fixed framesPerSecond, long bytesPerSecond)")},
    {"VDGetSoundInputDriver", (PyCFunction)Qt_VDGetSoundInputDriver, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, Str255 soundDriverName) -> (ComponentResult _rv)")},
    {"VDGetDMADepths", (PyCFunction)Qt_VDGetDMADepths, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long depthArray, long preferredDepth)")},
    {"VDGetPreferredTimeScale", (PyCFunction)Qt_VDGetPreferredTimeScale, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, TimeScale preferred)")},
    {"VDReleaseAsyncBuffers", (PyCFunction)Qt_VDReleaseAsyncBuffers, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv)")},
    {"VDSetDataRate", (PyCFunction)Qt_VDSetDataRate, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, long bytesPerSecond) -> (ComponentResult _rv)")},
    {"VDGetTimeCode", (PyCFunction)Qt_VDGetTimeCode, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, void * timeCodeFormat, void * timeCodeTime) -> (ComponentResult _rv, TimeRecord atTime)")},
    {"VDUseSafeBuffers", (PyCFunction)Qt_VDUseSafeBuffers, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, Boolean useSafeBuffers) -> (ComponentResult _rv)")},
    {"VDGetSoundInputSource", (PyCFunction)Qt_VDGetSoundInputSource, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, long videoInput) -> (ComponentResult _rv, long soundInput)")},
    {"VDGetCompressionTime", (PyCFunction)Qt_VDGetCompressionTime, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, OSType compressionType, short depth) -> (ComponentResult _rv, Rect srcRect, CodecQ spatialQuality, CodecQ temporalQuality, unsigned long compressTime)")},
    {"VDSetPreferredPacketSize", (PyCFunction)Qt_VDSetPreferredPacketSize, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, long preferredPacketSizeInBytes) -> (ComponentResult _rv)")},
    {"VDSetPreferredImageDimensions", (PyCFunction)Qt_VDSetPreferredImageDimensions, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, long width, long height) -> (ComponentResult _rv)")},
    {"VDGetPreferredImageDimensions", (PyCFunction)Qt_VDGetPreferredImageDimensions, 1,
     PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long width, long height)")},
    {"VDGetInputName", (PyCFunction)Qt_VDGetInputName, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, long videoInput, Str255 name) -> (ComponentResult _rv)")},
    {"VDSetDestinationPort", (PyCFunction)Qt_VDSetDestinationPort, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, CGrafPtr destPort) -> (ComponentResult _rv)")},
    {"VDGetDeviceNameAndFlags", (PyCFunction)Qt_VDGetDeviceNameAndFlags, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, Str255 outName) -> (ComponentResult _rv, UInt32 outNameFlags)")},
    {"VDCaptureStateChanging", (PyCFunction)Qt_VDCaptureStateChanging, 1,
     PyDoc_STR("(VideoDigitizerComponent ci, UInt32 inStateFlags) -> (ComponentResult _rv)")},
    {"XMLParseGetDetailedParseError", (PyCFunction)Qt_XMLParseGetDetailedParseError, 1,
     PyDoc_STR("(ComponentInstance aParser, StringPtr errDesc) -> (ComponentResult _rv, long errorLine)")},
    {"XMLParseAddElement", (PyCFunction)Qt_XMLParseAddElement, 1,
     PyDoc_STR("(ComponentInstance aParser, UInt32 nameSpaceID, long elementFlags) -> (ComponentResult _rv, char elementName, UInt32 elementID)")},
    {"XMLParseAddAttribute", (PyCFunction)Qt_XMLParseAddAttribute, 1,
     PyDoc_STR("(ComponentInstance aParser, UInt32 elementID, UInt32 nameSpaceID) -> (ComponentResult _rv, char attributeName, UInt32 attributeID)")},
    {"XMLParseAddMultipleAttributes", (PyCFunction)Qt_XMLParseAddMultipleAttributes, 1,
     PyDoc_STR("(ComponentInstance aParser, UInt32 elementID) -> (ComponentResult _rv, UInt32 nameSpaceIDs, char attributeNames, UInt32 attributeIDs)")},
    {"XMLParseAddAttributeAndValue", (PyCFunction)Qt_XMLParseAddAttributeAndValue, 1,
     PyDoc_STR("(ComponentInstance aParser, UInt32 elementID, UInt32 nameSpaceID, UInt32 attributeValueKind, void * attributeValueKindInfo) -> (ComponentResult _rv, char attributeName, UInt32 attributeID)")},
    {"XMLParseAddAttributeValueKind", (PyCFunction)Qt_XMLParseAddAttributeValueKind, 1,
     PyDoc_STR("(ComponentInstance aParser, UInt32 elementID, UInt32 attributeID, UInt32 attributeValueKind, void * attributeValueKindInfo) -> (ComponentResult _rv)")},
    {"XMLParseAddNameSpace", (PyCFunction)Qt_XMLParseAddNameSpace, 1,
     PyDoc_STR("(ComponentInstance aParser) -> (ComponentResult _rv, char nameSpaceURL, UInt32 nameSpaceID)")},
    {"XMLParseSetOffsetAndLimit", (PyCFunction)Qt_XMLParseSetOffsetAndLimit, 1,
     PyDoc_STR("(ComponentInstance aParser, UInt32 offset, UInt32 limit) -> (ComponentResult _rv)")},
    {"XMLParseSetEventParseRefCon", (PyCFunction)Qt_XMLParseSetEventParseRefCon, 1,
     PyDoc_STR("(ComponentInstance aParser, long refcon) -> (ComponentResult _rv)")},
    {"SGInitialize", (PyCFunction)Qt_SGInitialize, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
    {"SGSetDataOutput", (PyCFunction)Qt_SGSetDataOutput, 1,
     PyDoc_STR("(SeqGrabComponent s, FSSpec movieFile, long whereFlags) -> (ComponentResult _rv)")},
    {"SGGetDataOutput", (PyCFunction)Qt_SGGetDataOutput, 1,
     PyDoc_STR("(SeqGrabComponent s, FSSpec movieFile) -> (ComponentResult _rv, long whereFlags)")},
    {"SGSetGWorld", (PyCFunction)Qt_SGSetGWorld, 1,
     PyDoc_STR("(SeqGrabComponent s, CGrafPtr gp, GDHandle gd) -> (ComponentResult _rv)")},
    {"SGGetGWorld", (PyCFunction)Qt_SGGetGWorld, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, CGrafPtr gp, GDHandle gd)")},
    {"SGNewChannel", (PyCFunction)Qt_SGNewChannel, 1,
     PyDoc_STR("(SeqGrabComponent s, OSType channelType) -> (ComponentResult _rv, SGChannel ref)")},
    {"SGDisposeChannel", (PyCFunction)Qt_SGDisposeChannel, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c) -> (ComponentResult _rv)")},
    {"SGStartPreview", (PyCFunction)Qt_SGStartPreview, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
    {"SGStartRecord", (PyCFunction)Qt_SGStartRecord, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
    {"SGIdle", (PyCFunction)Qt_SGIdle, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
    {"SGStop", (PyCFunction)Qt_SGStop, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
    {"SGPause", (PyCFunction)Qt_SGPause, 1,
     PyDoc_STR("(SeqGrabComponent s, Boolean pause) -> (ComponentResult _rv)")},
    {"SGPrepare", (PyCFunction)Qt_SGPrepare, 1,
     PyDoc_STR("(SeqGrabComponent s, Boolean prepareForPreview, Boolean prepareForRecord) -> (ComponentResult _rv)")},
    {"SGRelease", (PyCFunction)Qt_SGRelease, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
    {"SGGetMovie", (PyCFunction)Qt_SGGetMovie, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (Movie _rv)")},
    {"SGSetMaximumRecordTime", (PyCFunction)Qt_SGSetMaximumRecordTime, 1,
     PyDoc_STR("(SeqGrabComponent s, unsigned long ticks) -> (ComponentResult _rv)")},
    {"SGGetMaximumRecordTime", (PyCFunction)Qt_SGGetMaximumRecordTime, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, unsigned long ticks)")},
    {"SGGetStorageSpaceRemaining", (PyCFunction)Qt_SGGetStorageSpaceRemaining, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, unsigned long bytes)")},
    {"SGGetTimeRemaining", (PyCFunction)Qt_SGGetTimeRemaining, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, long ticksLeft)")},
    {"SGGrabPict", (PyCFunction)Qt_SGGrabPict, 1,
     PyDoc_STR("(SeqGrabComponent s, Rect bounds, short offscreenDepth, long grabPictFlags) -> (ComponentResult _rv, PicHandle p)")},
    {"SGGetLastMovieResID", (PyCFunction)Qt_SGGetLastMovieResID, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, short resID)")},
    {"SGSetFlags", (PyCFunction)Qt_SGSetFlags, 1,
     PyDoc_STR("(SeqGrabComponent s, long sgFlags) -> (ComponentResult _rv)")},
    {"SGGetFlags", (PyCFunction)Qt_SGGetFlags, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, long sgFlags)")},
    {"SGNewChannelFromComponent", (PyCFunction)Qt_SGNewChannelFromComponent, 1,
     PyDoc_STR("(SeqGrabComponent s, Component sgChannelComponent) -> (ComponentResult _rv, SGChannel newChannel)")},
    {"SGSetSettings", (PyCFunction)Qt_SGSetSettings, 1,
     PyDoc_STR("(SeqGrabComponent s, UserData ud, long flags) -> (ComponentResult _rv)")},
    {"SGGetSettings", (PyCFunction)Qt_SGGetSettings, 1,
     PyDoc_STR("(SeqGrabComponent s, long flags) -> (ComponentResult _rv, UserData ud)")},
    {"SGGetIndChannel", (PyCFunction)Qt_SGGetIndChannel, 1,
     PyDoc_STR("(SeqGrabComponent s, short index) -> (ComponentResult _rv, SGChannel ref, OSType chanType)")},
    {"SGUpdate", (PyCFunction)Qt_SGUpdate, 1,
     PyDoc_STR("(SeqGrabComponent s, RgnHandle updateRgn) -> (ComponentResult _rv)")},
    {"SGGetPause", (PyCFunction)Qt_SGGetPause, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Boolean paused)")},
    {"SGSetChannelSettings", (PyCFunction)Qt_SGSetChannelSettings, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c, UserData ud, long flags) -> (ComponentResult _rv)")},
    {"SGGetChannelSettings", (PyCFunction)Qt_SGGetChannelSettings, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c, long flags) -> (ComponentResult _rv, UserData ud)")},
    {"SGGetMode", (PyCFunction)Qt_SGGetMode, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Boolean previewMode, Boolean recordMode)")},
    {"SGSetDataRef", (PyCFunction)Qt_SGSetDataRef, 1,
     PyDoc_STR("(SeqGrabComponent s, Handle dataRef, OSType dataRefType, long whereFlags) -> (ComponentResult _rv)")},
    {"SGGetDataRef", (PyCFunction)Qt_SGGetDataRef, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType, long whereFlags)")},
    {"SGNewOutput", (PyCFunction)Qt_SGNewOutput, 1,
     PyDoc_STR("(SeqGrabComponent s, Handle dataRef, OSType dataRefType, long whereFlags) -> (ComponentResult _rv, SGOutput sgOut)")},
    {"SGDisposeOutput", (PyCFunction)Qt_SGDisposeOutput, 1,
     PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv)")},
    {"SGSetOutputFlags", (PyCFunction)Qt_SGSetOutputFlags, 1,
     PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut, long whereFlags) -> (ComponentResult _rv)")},
    {"SGSetChannelOutput", (PyCFunction)Qt_SGSetChannelOutput, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c, SGOutput sgOut) -> (ComponentResult _rv)")},
    {"SGGetDataOutputStorageSpaceRemaining", (PyCFunction)Qt_SGGetDataOutputStorageSpaceRemaining, 1,
     PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, unsigned long space)")},
    {"SGHandleUpdateEvent", (PyCFunction)Qt_SGHandleUpdateEvent, 1,
     PyDoc_STR("(SeqGrabComponent s, EventRecord event) -> (ComponentResult _rv, Boolean handled)")},
    {"SGSetOutputNextOutput", (PyCFunction)Qt_SGSetOutputNextOutput, 1,
     PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut, SGOutput nextOut) -> (ComponentResult _rv)")},
    {"SGGetOutputNextOutput", (PyCFunction)Qt_SGGetOutputNextOutput, 1,
     PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, SGOutput nextOut)")},
    {"SGSetOutputMaximumOffset", (PyCFunction)Qt_SGSetOutputMaximumOffset, 1,
     PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut, wide maxOffset) -> (ComponentResult _rv)")},
    {"SGGetOutputMaximumOffset", (PyCFunction)Qt_SGGetOutputMaximumOffset, 1,
     PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, wide maxOffset)")},
    {"SGGetOutputDataReference", (PyCFunction)Qt_SGGetOutputDataReference, 1,
     PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType)")},
    {"SGWriteExtendedMovieData", (PyCFunction)Qt_SGWriteExtendedMovieData, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c, Ptr p, long len) -> (ComponentResult _rv, wide offset, SGOutput sgOut)")},
    {"SGGetStorageSpaceRemaining64", (PyCFunction)Qt_SGGetStorageSpaceRemaining64, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, wide bytes)")},
    {"SGGetDataOutputStorageSpaceRemaining64", (PyCFunction)Qt_SGGetDataOutputStorageSpaceRemaining64, 1,
     PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, wide space)")},
    {"SGWriteMovieData", (PyCFunction)Qt_SGWriteMovieData, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c, Ptr p, long len) -> (ComponentResult _rv, long offset)")},
    {"SGGetTimeBase", (PyCFunction)Qt_SGGetTimeBase, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, TimeBase tb)")},
    {"SGAddMovieData", (PyCFunction)Qt_SGAddMovieData, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c, Ptr p, long len, long chRefCon, TimeValue time, short writeType) -> (ComponentResult _rv, long offset)")},
    {"SGChangedSource", (PyCFunction)Qt_SGChangedSource, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c) -> (ComponentResult _rv)")},
    {"SGAddExtendedMovieData", (PyCFunction)Qt_SGAddExtendedMovieData, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c, Ptr p, long len, long chRefCon, TimeValue time, short writeType) -> (ComponentResult _rv, wide offset, SGOutput whichOutput)")},
    {"SGAddOutputDataRefToMedia", (PyCFunction)Qt_SGAddOutputDataRefToMedia, 1,
     PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut, Media theMedia, SampleDescriptionHandle desc) -> (ComponentResult _rv)")},
    {"SGSetSettingsSummary", (PyCFunction)Qt_SGSetSettingsSummary, 1,
     PyDoc_STR("(SeqGrabComponent s, Handle summaryText) -> (ComponentResult _rv)")},
    {"SGSetChannelUsage", (PyCFunction)Qt_SGSetChannelUsage, 1,
     PyDoc_STR("(SGChannel c, long usage) -> (ComponentResult _rv)")},
    {"SGGetChannelUsage", (PyCFunction)Qt_SGGetChannelUsage, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long usage)")},
    {"SGSetChannelBounds", (PyCFunction)Qt_SGSetChannelBounds, 1,
     PyDoc_STR("(SGChannel c, Rect bounds) -> (ComponentResult _rv)")},
    {"SGGetChannelBounds", (PyCFunction)Qt_SGGetChannelBounds, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Rect bounds)")},
    {"SGSetChannelVolume", (PyCFunction)Qt_SGSetChannelVolume, 1,
     PyDoc_STR("(SGChannel c, short volume) -> (ComponentResult _rv)")},
    {"SGGetChannelVolume", (PyCFunction)Qt_SGGetChannelVolume, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short volume)")},
    {"SGGetChannelInfo", (PyCFunction)Qt_SGGetChannelInfo, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long channelInfo)")},
    {"SGSetChannelPlayFlags", (PyCFunction)Qt_SGSetChannelPlayFlags, 1,
     PyDoc_STR("(SGChannel c, long playFlags) -> (ComponentResult _rv)")},
    {"SGGetChannelPlayFlags", (PyCFunction)Qt_SGGetChannelPlayFlags, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long playFlags)")},
    {"SGSetChannelMaxFrames", (PyCFunction)Qt_SGSetChannelMaxFrames, 1,
     PyDoc_STR("(SGChannel c, long frameCount) -> (ComponentResult _rv)")},
    {"SGGetChannelMaxFrames", (PyCFunction)Qt_SGGetChannelMaxFrames, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long frameCount)")},
    {"SGSetChannelRefCon", (PyCFunction)Qt_SGSetChannelRefCon, 1,
     PyDoc_STR("(SGChannel c, long refCon) -> (ComponentResult _rv)")},
    {"SGSetChannelClip", (PyCFunction)Qt_SGSetChannelClip, 1,
     PyDoc_STR("(SGChannel c, RgnHandle theClip) -> (ComponentResult _rv)")},
    {"SGGetChannelClip", (PyCFunction)Qt_SGGetChannelClip, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, RgnHandle theClip)")},
    {"SGGetChannelSampleDescription", (PyCFunction)Qt_SGGetChannelSampleDescription, 1,
     PyDoc_STR("(SGChannel c, Handle sampleDesc) -> (ComponentResult _rv)")},
    {"SGSetChannelDevice", (PyCFunction)Qt_SGSetChannelDevice, 1,
     PyDoc_STR("(SGChannel c, StringPtr name) -> (ComponentResult _rv)")},
    {"SGGetChannelTimeScale", (PyCFunction)Qt_SGGetChannelTimeScale, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, TimeScale scale)")},
    {"SGChannelPutPicture", (PyCFunction)Qt_SGChannelPutPicture, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv)")},
    {"SGChannelSetRequestedDataRate", (PyCFunction)Qt_SGChannelSetRequestedDataRate, 1,
     PyDoc_STR("(SGChannel c, long bytesPerSecond) -> (ComponentResult _rv)")},
    {"SGChannelGetRequestedDataRate", (PyCFunction)Qt_SGChannelGetRequestedDataRate, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long bytesPerSecond)")},
    {"SGChannelSetDataSourceName", (PyCFunction)Qt_SGChannelSetDataSourceName, 1,
     PyDoc_STR("(SGChannel c, Str255 name, ScriptCode scriptTag) -> (ComponentResult _rv)")},
    {"SGChannelGetDataSourceName", (PyCFunction)Qt_SGChannelGetDataSourceName, 1,
     PyDoc_STR("(SGChannel c, Str255 name) -> (ComponentResult _rv, ScriptCode scriptTag)")},
    {"SGChannelSetCodecSettings", (PyCFunction)Qt_SGChannelSetCodecSettings, 1,
     PyDoc_STR("(SGChannel c, Handle settings) -> (ComponentResult _rv)")},
    {"SGChannelGetCodecSettings", (PyCFunction)Qt_SGChannelGetCodecSettings, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Handle settings)")},
    {"SGGetChannelTimeBase", (PyCFunction)Qt_SGGetChannelTimeBase, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, TimeBase tb)")},
    {"SGGetChannelRefCon", (PyCFunction)Qt_SGGetChannelRefCon, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long refCon)")},
    {"SGGetChannelDeviceAndInputNames", (PyCFunction)Qt_SGGetChannelDeviceAndInputNames, 1,
     PyDoc_STR("(SGChannel c, Str255 outDeviceName, Str255 outInputName) -> (ComponentResult _rv, short outInputNumber)")},
    {"SGSetChannelDeviceInput", (PyCFunction)Qt_SGSetChannelDeviceInput, 1,
     PyDoc_STR("(SGChannel c, short inInputNumber) -> (ComponentResult _rv)")},
    {"SGSetChannelSettingsStateChanging", (PyCFunction)Qt_SGSetChannelSettingsStateChanging, 1,
     PyDoc_STR("(SGChannel c, UInt32 inFlags) -> (ComponentResult _rv)")},
    {"SGInitChannel", (PyCFunction)Qt_SGInitChannel, 1,
     PyDoc_STR("(SGChannel c, SeqGrabComponent owner) -> (ComponentResult _rv)")},
    {"SGWriteSamples", (PyCFunction)Qt_SGWriteSamples, 1,
     PyDoc_STR("(SGChannel c, Movie m, AliasHandle theFile) -> (ComponentResult _rv)")},
    {"SGGetDataRate", (PyCFunction)Qt_SGGetDataRate, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long bytesPerSecond)")},
    {"SGAlignChannelRect", (PyCFunction)Qt_SGAlignChannelRect, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Rect r)")},
    {"SGPanelGetDitl", (PyCFunction)Qt_SGPanelGetDitl, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Handle ditl)")},
    {"SGPanelGetTitle", (PyCFunction)Qt_SGPanelGetTitle, 1,
     PyDoc_STR("(SeqGrabComponent s, Str255 title) -> (ComponentResult _rv)")},
    {"SGPanelCanRun", (PyCFunction)Qt_SGPanelCanRun, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c) -> (ComponentResult _rv)")},
    {"SGPanelInstall", (PyCFunction)Qt_SGPanelInstall, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset) -> (ComponentResult _rv)")},
    {"SGPanelEvent", (PyCFunction)Qt_SGPanelEvent, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset, EventRecord theEvent) -> (ComponentResult _rv, short itemHit, Boolean handled)")},
    {"SGPanelItem", (PyCFunction)Qt_SGPanelItem, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset, short itemNum) -> (ComponentResult _rv)")},
    {"SGPanelRemove", (PyCFunction)Qt_SGPanelRemove, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset) -> (ComponentResult _rv)")},
    {"SGPanelSetGrabber", (PyCFunction)Qt_SGPanelSetGrabber, 1,
     PyDoc_STR("(SeqGrabComponent s, SeqGrabComponent sg) -> (ComponentResult _rv)")},
    {"SGPanelSetResFile", (PyCFunction)Qt_SGPanelSetResFile, 1,
     PyDoc_STR("(SeqGrabComponent s, short resRef) -> (ComponentResult _rv)")},
    {"SGPanelGetSettings", (PyCFunction)Qt_SGPanelGetSettings, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c, long flags) -> (ComponentResult _rv, UserData ud)")},
    {"SGPanelSetSettings", (PyCFunction)Qt_SGPanelSetSettings, 1,
     PyDoc_STR("(SeqGrabComponent s, SGChannel c, UserData ud, long flags) -> (ComponentResult _rv)")},
    {"SGPanelValidateInput", (PyCFunction)Qt_SGPanelValidateInput, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Boolean ok)")},
    {"SGPanelGetDITLForSize", (PyCFunction)Qt_SGPanelGetDITLForSize, 1,
     PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Handle ditl, Point requestedSize)")},
    {"SGGetSrcVideoBounds", (PyCFunction)Qt_SGGetSrcVideoBounds, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Rect r)")},
    {"SGSetVideoRect", (PyCFunction)Qt_SGSetVideoRect, 1,
     PyDoc_STR("(SGChannel c, Rect r) -> (ComponentResult _rv)")},
    {"SGGetVideoRect", (PyCFunction)Qt_SGGetVideoRect, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Rect r)")},
    {"SGGetVideoCompressorType", (PyCFunction)Qt_SGGetVideoCompressorType, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, OSType compressorType)")},
    {"SGSetVideoCompressorType", (PyCFunction)Qt_SGSetVideoCompressorType, 1,
     PyDoc_STR("(SGChannel c, OSType compressorType) -> (ComponentResult _rv)")},
    {"SGSetVideoCompressor", (PyCFunction)Qt_SGSetVideoCompressor, 1,
     PyDoc_STR("(SGChannel c, short depth, CompressorComponent compressor, CodecQ spatialQuality, CodecQ temporalQuality, long keyFrameRate) -> (ComponentResult _rv)")},
    {"SGGetVideoCompressor", (PyCFunction)Qt_SGGetVideoCompressor, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short depth, CompressorComponent compressor, CodecQ spatialQuality, CodecQ temporalQuality, long keyFrameRate)")},
    {"SGGetVideoDigitizerComponent", (PyCFunction)Qt_SGGetVideoDigitizerComponent, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentInstance _rv)")},
    {"SGSetVideoDigitizerComponent", (PyCFunction)Qt_SGSetVideoDigitizerComponent, 1,
     PyDoc_STR("(SGChannel c, ComponentInstance vdig) -> (ComponentResult _rv)")},
    {"SGVideoDigitizerChanged", (PyCFunction)Qt_SGVideoDigitizerChanged, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv)")},
    {"SGGrabFrame", (PyCFunction)Qt_SGGrabFrame, 1,
     PyDoc_STR("(SGChannel c, short bufferNum) -> (ComponentResult _rv)")},
    {"SGGrabFrameComplete", (PyCFunction)Qt_SGGrabFrameComplete, 1,
     PyDoc_STR("(SGChannel c, short bufferNum) -> (ComponentResult _rv, Boolean done)")},
    {"SGCompressFrame", (PyCFunction)Qt_SGCompressFrame, 1,
     PyDoc_STR("(SGChannel c, short bufferNum) -> (ComponentResult _rv)")},
    {"SGSetCompressBuffer", (PyCFunction)Qt_SGSetCompressBuffer, 1,
     PyDoc_STR("(SGChannel c, short depth, Rect compressSize) -> (ComponentResult _rv)")},
    {"SGGetCompressBuffer", (PyCFunction)Qt_SGGetCompressBuffer, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short depth, Rect compressSize)")},
    {"SGGetBufferInfo", (PyCFunction)Qt_SGGetBufferInfo, 1,
     PyDoc_STR("(SGChannel c, short bufferNum) -> (ComponentResult _rv, PixMapHandle bufferPM, Rect bufferRect, GWorldPtr compressBuffer, Rect compressBufferRect)")},
    {"SGSetUseScreenBuffer", (PyCFunction)Qt_SGSetUseScreenBuffer, 1,
     PyDoc_STR("(SGChannel c, Boolean useScreenBuffer) -> (ComponentResult _rv)")},
    {"SGGetUseScreenBuffer", (PyCFunction)Qt_SGGetUseScreenBuffer, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Boolean useScreenBuffer)")},
    {"SGSetFrameRate", (PyCFunction)Qt_SGSetFrameRate, 1,
     PyDoc_STR("(SGChannel c, Fixed frameRate) -> (ComponentResult _rv)")},
    {"SGGetFrameRate", (PyCFunction)Qt_SGGetFrameRate, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Fixed frameRate)")},
    {"SGSetPreferredPacketSize", (PyCFunction)Qt_SGSetPreferredPacketSize, 1,
     PyDoc_STR("(SGChannel c, long preferredPacketSizeInBytes) -> (ComponentResult _rv)")},
    {"SGGetPreferredPacketSize", (PyCFunction)Qt_SGGetPreferredPacketSize, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long preferredPacketSizeInBytes)")},
    {"SGSetUserVideoCompressorList", (PyCFunction)Qt_SGSetUserVideoCompressorList, 1,
     PyDoc_STR("(SGChannel c, Handle compressorTypes) -> (ComponentResult _rv)")},
    {"SGGetUserVideoCompressorList", (PyCFunction)Qt_SGGetUserVideoCompressorList, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Handle compressorTypes)")},
    {"SGSetSoundInputDriver", (PyCFunction)Qt_SGSetSoundInputDriver, 1,
     PyDoc_STR("(SGChannel c, Str255 driverName) -> (ComponentResult _rv)")},
    {"SGGetSoundInputDriver", (PyCFunction)Qt_SGGetSoundInputDriver, 1,
     PyDoc_STR("(SGChannel c) -> (long _rv)")},
    {"SGSoundInputDriverChanged", (PyCFunction)Qt_SGSoundInputDriverChanged, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv)")},
    {"SGSetSoundRecordChunkSize", (PyCFunction)Qt_SGSetSoundRecordChunkSize, 1,
     PyDoc_STR("(SGChannel c, long seconds) -> (ComponentResult _rv)")},
    {"SGGetSoundRecordChunkSize", (PyCFunction)Qt_SGGetSoundRecordChunkSize, 1,
     PyDoc_STR("(SGChannel c) -> (long _rv)")},
    {"SGSetSoundInputRate", (PyCFunction)Qt_SGSetSoundInputRate, 1,
     PyDoc_STR("(SGChannel c, Fixed rate) -> (ComponentResult _rv)")},
    {"SGGetSoundInputRate", (PyCFunction)Qt_SGGetSoundInputRate, 1,
     PyDoc_STR("(SGChannel c) -> (Fixed _rv)")},
    {"SGSetSoundInputParameters", (PyCFunction)Qt_SGSetSoundInputParameters, 1,
     PyDoc_STR("(SGChannel c, short sampleSize, short numChannels, OSType compressionType) -> (ComponentResult _rv)")},
    {"SGGetSoundInputParameters", (PyCFunction)Qt_SGGetSoundInputParameters, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short sampleSize, short numChannels, OSType compressionType)")},
    {"SGSetAdditionalSoundRates", (PyCFunction)Qt_SGSetAdditionalSoundRates, 1,
     PyDoc_STR("(SGChannel c, Handle rates) -> (ComponentResult _rv)")},
    {"SGGetAdditionalSoundRates", (PyCFunction)Qt_SGGetAdditionalSoundRates, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Handle rates)")},
    {"SGSetFontName", (PyCFunction)Qt_SGSetFontName, 1,
     PyDoc_STR("(SGChannel c, StringPtr pstr) -> (ComponentResult _rv)")},
    {"SGSetFontSize", (PyCFunction)Qt_SGSetFontSize, 1,
     PyDoc_STR("(SGChannel c, short fontSize) -> (ComponentResult _rv)")},
    {"SGSetTextForeColor", (PyCFunction)Qt_SGSetTextForeColor, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, RGBColor theColor)")},
    {"SGSetTextBackColor", (PyCFunction)Qt_SGSetTextBackColor, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, RGBColor theColor)")},
    {"SGSetJustification", (PyCFunction)Qt_SGSetJustification, 1,
     PyDoc_STR("(SGChannel c, short just) -> (ComponentResult _rv)")},
    {"SGGetTextReturnToSpaceValue", (PyCFunction)Qt_SGGetTextReturnToSpaceValue, 1,
     PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short rettospace)")},
    {"SGSetTextReturnToSpaceValue", (PyCFunction)Qt_SGSetTextReturnToSpaceValue, 1,
     PyDoc_STR("(SGChannel c, short rettospace) -> (ComponentResult _rv)")},
    {"QTVideoOutputGetCurrentClientName", (PyCFunction)Qt_QTVideoOutputGetCurrentClientName, 1,
     PyDoc_STR("(QTVideoOutputComponent vo, Str255 str) -> (ComponentResult _rv)")},
    {"QTVideoOutputSetClientName", (PyCFunction)Qt_QTVideoOutputSetClientName, 1,
     PyDoc_STR("(QTVideoOutputComponent vo, Str255 str) -> (ComponentResult _rv)")},
    {"QTVideoOutputGetClientName", (PyCFunction)Qt_QTVideoOutputGetClientName, 1,
     PyDoc_STR("(QTVideoOutputComponent vo, Str255 str) -> (ComponentResult _rv)")},
    {"QTVideoOutputBegin", (PyCFunction)Qt_QTVideoOutputBegin, 1,
     PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv)")},
    {"QTVideoOutputEnd", (PyCFunction)Qt_QTVideoOutputEnd, 1,
     PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv)")},
    {"QTVideoOutputSetDisplayMode", (PyCFunction)Qt_QTVideoOutputSetDisplayMode, 1,
     PyDoc_STR("(QTVideoOutputComponent vo, long displayModeID) -> (ComponentResult _rv)")},
    {"QTVideoOutputGetDisplayMode", (PyCFunction)Qt_QTVideoOutputGetDisplayMode, 1,
     PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv, long displayModeID)")},
    {"QTVideoOutputGetGWorld", (PyCFunction)Qt_QTVideoOutputGetGWorld, 1,
     PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv, GWorldPtr gw)")},
    {"QTVideoOutputGetIndSoundOutput", (PyCFunction)Qt_QTVideoOutputGetIndSoundOutput, 1,
     PyDoc_STR("(QTVideoOutputComponent vo, long index) -> (ComponentResult _rv, Component outputComponent)")},
    {"QTVideoOutputGetClock", (PyCFunction)Qt_QTVideoOutputGetClock, 1,
     PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv, ComponentInstance clock)")},
    {"QTVideoOutputSetEchoPort", (PyCFunction)Qt_QTVideoOutputSetEchoPort, 1,
     PyDoc_STR("(QTVideoOutputComponent vo, CGrafPtr echoPort) -> (ComponentResult _rv)")},
    {"QTVideoOutputGetIndImageDecompressor", (PyCFunction)Qt_QTVideoOutputGetIndImageDecompressor, 1,
     PyDoc_STR("(QTVideoOutputComponent vo, long index) -> (ComponentResult _rv, Component codec)")},
    {"QTVideoOutputBaseSetEchoPort", (PyCFunction)Qt_QTVideoOutputBaseSetEchoPort, 1,
     PyDoc_STR("(QTVideoOutputComponent vo, CGrafPtr echoPort) -> (ComponentResult _rv)")},
    {"MediaSetChunkManagementFlags", (PyCFunction)Qt_MediaSetChunkManagementFlags, 1,
     PyDoc_STR("(MediaHandler mh, UInt32 flags, UInt32 flagsMask) -> (ComponentResult _rv)")},
    {"MediaGetChunkManagementFlags", (PyCFunction)Qt_MediaGetChunkManagementFlags, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, UInt32 flags)")},
    {"MediaSetPurgeableChunkMemoryAllowance", (PyCFunction)Qt_MediaSetPurgeableChunkMemoryAllowance, 1,
     PyDoc_STR("(MediaHandler mh, Size allowance) -> (ComponentResult _rv)")},
    {"MediaGetPurgeableChunkMemoryAllowance", (PyCFunction)Qt_MediaGetPurgeableChunkMemoryAllowance, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, Size allowance)")},
    {"MediaEmptyAllPurgeableChunks", (PyCFunction)Qt_MediaEmptyAllPurgeableChunks, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
    {"MediaSetHandlerCapabilities", (PyCFunction)Qt_MediaSetHandlerCapabilities, 1,
     PyDoc_STR("(MediaHandler mh, long flags, long flagsMask) -> (ComponentResult _rv)")},
    {"MediaIdle", (PyCFunction)Qt_MediaIdle, 1,
     PyDoc_STR("(MediaHandler mh, TimeValue atMediaTime, long flagsIn, TimeRecord movieTime) -> (ComponentResult _rv, long flagsOut)")},
    {"MediaGetMediaInfo", (PyCFunction)Qt_MediaGetMediaInfo, 1,
     PyDoc_STR("(MediaHandler mh, Handle h) -> (ComponentResult _rv)")},
    {"MediaPutMediaInfo", (PyCFunction)Qt_MediaPutMediaInfo, 1,
     PyDoc_STR("(MediaHandler mh, Handle h) -> (ComponentResult _rv)")},
    {"MediaSetActive", (PyCFunction)Qt_MediaSetActive, 1,
     PyDoc_STR("(MediaHandler mh, Boolean enableMedia) -> (ComponentResult _rv)")},
    {"MediaSetRate", (PyCFunction)Qt_MediaSetRate, 1,
     PyDoc_STR("(MediaHandler mh, Fixed rate) -> (ComponentResult _rv)")},
    {"MediaGGetStatus", (PyCFunction)Qt_MediaGGetStatus, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, ComponentResult statusErr)")},
    {"MediaTrackEdited", (PyCFunction)Qt_MediaTrackEdited, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
    {"MediaSetMediaTimeScale", (PyCFunction)Qt_MediaSetMediaTimeScale, 1,
     PyDoc_STR("(MediaHandler mh, TimeScale newTimeScale) -> (ComponentResult _rv)")},
    {"MediaSetMovieTimeScale", (PyCFunction)Qt_MediaSetMovieTimeScale, 1,
     PyDoc_STR("(MediaHandler mh, TimeScale newTimeScale) -> (ComponentResult _rv)")},
    {"MediaSetGWorld", (PyCFunction)Qt_MediaSetGWorld, 1,
     PyDoc_STR("(MediaHandler mh, CGrafPtr aPort, GDHandle aGD) -> (ComponentResult _rv)")},
    {"MediaSetDimensions", (PyCFunction)Qt_MediaSetDimensions, 1,
     PyDoc_STR("(MediaHandler mh, Fixed width, Fixed height) -> (ComponentResult _rv)")},
    {"MediaSetClip", (PyCFunction)Qt_MediaSetClip, 1,
     PyDoc_STR("(MediaHandler mh, RgnHandle theClip) -> (ComponentResult _rv)")},
    {"MediaGetTrackOpaque", (PyCFunction)Qt_MediaGetTrackOpaque, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, Boolean trackIsOpaque)")},
    {"MediaSetGraphicsMode", (PyCFunction)Qt_MediaSetGraphicsMode, 1,
     PyDoc_STR("(MediaHandler mh, long mode, RGBColor opColor) -> (ComponentResult _rv)")},
    {"MediaGetGraphicsMode", (PyCFunction)Qt_MediaGetGraphicsMode, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long mode, RGBColor opColor)")},
    {"MediaGSetVolume", (PyCFunction)Qt_MediaGSetVolume, 1,
     PyDoc_STR("(MediaHandler mh, short volume) -> (ComponentResult _rv)")},
    {"MediaSetSoundBalance", (PyCFunction)Qt_MediaSetSoundBalance, 1,
     PyDoc_STR("(MediaHandler mh, short balance) -> (ComponentResult _rv)")},
    {"MediaGetSoundBalance", (PyCFunction)Qt_MediaGetSoundBalance, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short balance)")},
    {"MediaGetNextBoundsChange", (PyCFunction)Qt_MediaGetNextBoundsChange, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, TimeValue when)")},
    {"MediaGetSrcRgn", (PyCFunction)Qt_MediaGetSrcRgn, 1,
     PyDoc_STR("(MediaHandler mh, RgnHandle rgn, TimeValue atMediaTime) -> (ComponentResult _rv)")},
    {"MediaPreroll", (PyCFunction)Qt_MediaPreroll, 1,
     PyDoc_STR("(MediaHandler mh, TimeValue time, Fixed rate) -> (ComponentResult _rv)")},
    {"MediaSampleDescriptionChanged", (PyCFunction)Qt_MediaSampleDescriptionChanged, 1,
     PyDoc_STR("(MediaHandler mh, long index) -> (ComponentResult _rv)")},
    {"MediaHasCharacteristic", (PyCFunction)Qt_MediaHasCharacteristic, 1,
     PyDoc_STR("(MediaHandler mh, OSType characteristic) -> (ComponentResult _rv, Boolean hasIt)")},
    {"MediaGetOffscreenBufferSize", (PyCFunction)Qt_MediaGetOffscreenBufferSize, 1,
     PyDoc_STR("(MediaHandler mh, short depth, CTabHandle ctab) -> (ComponentResult _rv, Rect bounds)")},
    {"MediaSetHints", (PyCFunction)Qt_MediaSetHints, 1,
     PyDoc_STR("(MediaHandler mh, long hints) -> (ComponentResult _rv)")},
    {"MediaGetName", (PyCFunction)Qt_MediaGetName, 1,
     PyDoc_STR("(MediaHandler mh, Str255 name, long requestedLanguage) -> (ComponentResult _rv, long actualLanguage)")},
    {"MediaForceUpdate", (PyCFunction)Qt_MediaForceUpdate, 1,
     PyDoc_STR("(MediaHandler mh, long forceUpdateFlags) -> (ComponentResult _rv)")},
    {"MediaGetDrawingRgn", (PyCFunction)Qt_MediaGetDrawingRgn, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, RgnHandle partialRgn)")},
    {"MediaGSetActiveSegment", (PyCFunction)Qt_MediaGSetActiveSegment, 1,
     PyDoc_STR("(MediaHandler mh, TimeValue activeStart, TimeValue activeDuration) -> (ComponentResult _rv)")},
    {"MediaInvalidateRegion", (PyCFunction)Qt_MediaInvalidateRegion, 1,
     PyDoc_STR("(MediaHandler mh, RgnHandle invalRgn) -> (ComponentResult _rv)")},
    {"MediaGetNextStepTime", (PyCFunction)Qt_MediaGetNextStepTime, 1,
     PyDoc_STR("(MediaHandler mh, short flags, TimeValue mediaTimeIn, Fixed rate) -> (ComponentResult _rv, TimeValue mediaTimeOut)")},
    {"MediaChangedNonPrimarySource", (PyCFunction)Qt_MediaChangedNonPrimarySource, 1,
     PyDoc_STR("(MediaHandler mh, long inputIndex) -> (ComponentResult _rv)")},
    {"MediaTrackReferencesChanged", (PyCFunction)Qt_MediaTrackReferencesChanged, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
    {"MediaReleaseSampleDataPointer", (PyCFunction)Qt_MediaReleaseSampleDataPointer, 1,
     PyDoc_STR("(MediaHandler mh, long sampleNum) -> (ComponentResult _rv)")},
    {"MediaTrackPropertyAtomChanged", (PyCFunction)Qt_MediaTrackPropertyAtomChanged, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
    {"MediaSetVideoParam", (PyCFunction)Qt_MediaSetVideoParam, 1,
     PyDoc_STR("(MediaHandler mh, long whichParam) -> (ComponentResult _rv, unsigned short value)")},
    {"MediaGetVideoParam", (PyCFunction)Qt_MediaGetVideoParam, 1,
     PyDoc_STR("(MediaHandler mh, long whichParam) -> (ComponentResult _rv, unsigned short value)")},
    {"MediaCompare", (PyCFunction)Qt_MediaCompare, 1,
     PyDoc_STR("(MediaHandler mh, Media srcMedia, ComponentInstance srcMediaComponent) -> (ComponentResult _rv, Boolean isOK)")},
    {"MediaGetClock", (PyCFunction)Qt_MediaGetClock, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, ComponentInstance clock)")},
    {"MediaSetSoundOutputComponent", (PyCFunction)Qt_MediaSetSoundOutputComponent, 1,
     PyDoc_STR("(MediaHandler mh, Component outputComponent) -> (ComponentResult _rv)")},
    {"MediaGetSoundOutputComponent", (PyCFunction)Qt_MediaGetSoundOutputComponent, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, Component outputComponent)")},
    {"MediaSetSoundLocalizationData", (PyCFunction)Qt_MediaSetSoundLocalizationData, 1,
     PyDoc_STR("(MediaHandler mh, Handle data) -> (ComponentResult _rv)")},
    {"MediaGetInvalidRegion", (PyCFunction)Qt_MediaGetInvalidRegion, 1,
     PyDoc_STR("(MediaHandler mh, RgnHandle rgn) -> (ComponentResult _rv)")},
    {"MediaSampleDescriptionB2N", (PyCFunction)Qt_MediaSampleDescriptionB2N, 1,
     PyDoc_STR("(MediaHandler mh, SampleDescriptionHandle sampleDescriptionH) -> (ComponentResult _rv)")},
    {"MediaSampleDescriptionN2B", (PyCFunction)Qt_MediaSampleDescriptionN2B, 1,
     PyDoc_STR("(MediaHandler mh, SampleDescriptionHandle sampleDescriptionH) -> (ComponentResult _rv)")},
    {"MediaFlushNonPrimarySourceData", (PyCFunction)Qt_MediaFlushNonPrimarySourceData, 1,
     PyDoc_STR("(MediaHandler mh, long inputIndex) -> (ComponentResult _rv)")},
    {"MediaGetURLLink", (PyCFunction)Qt_MediaGetURLLink, 1,
     PyDoc_STR("(MediaHandler mh, Point displayWhere) -> (ComponentResult _rv, Handle urlLink)")},
    {"MediaHitTestForTargetRefCon", (PyCFunction)Qt_MediaHitTestForTargetRefCon, 1,
     PyDoc_STR("(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, long targetRefCon)")},
    {"MediaHitTestTargetRefCon", (PyCFunction)Qt_MediaHitTestTargetRefCon, 1,
     PyDoc_STR("(MediaHandler mh, long targetRefCon, long flags, Point loc) -> (ComponentResult _rv, Boolean wasHit)")},
    {"MediaDisposeTargetRefCon", (PyCFunction)Qt_MediaDisposeTargetRefCon, 1,
     PyDoc_STR("(MediaHandler mh, long targetRefCon) -> (ComponentResult _rv)")},
    {"MediaTargetRefConsEqual", (PyCFunction)Qt_MediaTargetRefConsEqual, 1,
     PyDoc_STR("(MediaHandler mh, long firstRefCon, long secondRefCon) -> (ComponentResult _rv, Boolean equal)")},
    {"MediaPrePrerollCancel", (PyCFunction)Qt_MediaPrePrerollCancel, 1,
     PyDoc_STR("(MediaHandler mh, void * refcon) -> (ComponentResult _rv)")},
    {"MediaEnterEmptyEdit", (PyCFunction)Qt_MediaEnterEmptyEdit, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
    {"MediaCurrentMediaQueuedData", (PyCFunction)Qt_MediaCurrentMediaQueuedData, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long milliSecs)")},
    {"MediaGetEffectiveVolume", (PyCFunction)Qt_MediaGetEffectiveVolume, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short volume)")},
    {"MediaGetSoundLevelMeteringEnabled", (PyCFunction)Qt_MediaGetSoundLevelMeteringEnabled, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, Boolean enabled)")},
    {"MediaSetSoundLevelMeteringEnabled", (PyCFunction)Qt_MediaSetSoundLevelMeteringEnabled, 1,
     PyDoc_STR("(MediaHandler mh, Boolean enable) -> (ComponentResult _rv)")},
    {"MediaGetEffectiveSoundBalance", (PyCFunction)Qt_MediaGetEffectiveSoundBalance, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short balance)")},
    {"MediaSetScreenLock", (PyCFunction)Qt_MediaSetScreenLock, 1,
     PyDoc_STR("(MediaHandler mh, Boolean lockIt) -> (ComponentResult _rv)")},
    {"MediaGetErrorString", (PyCFunction)Qt_MediaGetErrorString, 1,
     PyDoc_STR("(MediaHandler mh, ComponentResult theError, Str255 errorString) -> (ComponentResult _rv)")},
    {"MediaGetSoundEqualizerBandLevels", (PyCFunction)Qt_MediaGetSoundEqualizerBandLevels, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, UInt8 bandLevels)")},
    {"MediaDoIdleActions", (PyCFunction)Qt_MediaDoIdleActions, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
    {"MediaSetSoundBassAndTreble", (PyCFunction)Qt_MediaSetSoundBassAndTreble, 1,
     PyDoc_STR("(MediaHandler mh, short bass, short treble) -> (ComponentResult _rv)")},
    {"MediaGetSoundBassAndTreble", (PyCFunction)Qt_MediaGetSoundBassAndTreble, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short bass, short treble)")},
    {"MediaTimeBaseChanged", (PyCFunction)Qt_MediaTimeBaseChanged, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
    {"MediaMCIsPlayerEvent", (PyCFunction)Qt_MediaMCIsPlayerEvent, 1,
     PyDoc_STR("(MediaHandler mh, EventRecord e) -> (ComponentResult _rv, Boolean handledIt)")},
    {"MediaGetMediaLoadState", (PyCFunction)Qt_MediaGetMediaLoadState, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long mediaLoadState)")},
    {"MediaVideoOutputChanged", (PyCFunction)Qt_MediaVideoOutputChanged, 1,
     PyDoc_STR("(MediaHandler mh, ComponentInstance vout) -> (ComponentResult _rv)")},
    {"MediaEmptySampleCache", (PyCFunction)Qt_MediaEmptySampleCache, 1,
     PyDoc_STR("(MediaHandler mh, long sampleNum, long sampleCount) -> (ComponentResult _rv)")},
    {"MediaGetPublicInfo", (PyCFunction)Qt_MediaGetPublicInfo, 1,
     PyDoc_STR("(MediaHandler mh, OSType infoSelector, void * infoDataPtr) -> (ComponentResult _rv, Size ioDataSize)")},
    {"MediaSetPublicInfo", (PyCFunction)Qt_MediaSetPublicInfo, 1,
     PyDoc_STR("(MediaHandler mh, OSType infoSelector, void * infoDataPtr, Size dataSize) -> (ComponentResult _rv)")},
    {"MediaRefConSetProperty", (PyCFunction)Qt_MediaRefConSetProperty, 1,
     PyDoc_STR("(MediaHandler mh, long refCon, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
    {"MediaRefConGetProperty", (PyCFunction)Qt_MediaRefConGetProperty, 1,
     PyDoc_STR("(MediaHandler mh, long refCon, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
    {"MediaNavigateTargetRefCon", (PyCFunction)Qt_MediaNavigateTargetRefCon, 1,
     PyDoc_STR("(MediaHandler mh, long navigation) -> (ComponentResult _rv, long refCon)")},
    {"MediaGGetIdleManager", (PyCFunction)Qt_MediaGGetIdleManager, 1,
     PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, IdleManager pim)")},
    {"MediaGSetIdleManager", (PyCFunction)Qt_MediaGSetIdleManager, 1,
     PyDoc_STR("(MediaHandler mh, IdleManager im) -> (ComponentResult _rv)")},
    {"QTMIDIGetMIDIPorts", (PyCFunction)Qt_QTMIDIGetMIDIPorts, 1,
     PyDoc_STR("(QTMIDIComponent ci) -> (ComponentResult _rv, QTMIDIPortListHandle inputPorts, QTMIDIPortListHandle outputPorts)")},
    {"QTMIDIUseSendPort", (PyCFunction)Qt_QTMIDIUseSendPort, 1,
     PyDoc_STR("(QTMIDIComponent ci, long portIndex, long inUse) -> (ComponentResult _rv)")},
    {"QTMIDISendMIDI", (PyCFunction)Qt_QTMIDISendMIDI, 1,
     PyDoc_STR("(QTMIDIComponent ci, long portIndex, MusicMIDIPacket mp) -> (ComponentResult _rv)")},
    {"MusicGetPart", (PyCFunction)Qt_MusicGetPart, 1,
     PyDoc_STR("(MusicComponent mc, long part) -> (ComponentResult _rv, long midiChannel, long polyphony)")},
    {"MusicSetPart", (PyCFunction)Qt_MusicSetPart, 1,
     PyDoc_STR("(MusicComponent mc, long part, long midiChannel, long polyphony) -> (ComponentResult _rv)")},
    {"MusicSetPartInstrumentNumber", (PyCFunction)Qt_MusicSetPartInstrumentNumber, 1,
     PyDoc_STR("(MusicComponent mc, long part, long instrumentNumber) -> (ComponentResult _rv)")},
    {"MusicGetPartInstrumentNumber", (PyCFunction)Qt_MusicGetPartInstrumentNumber, 1,
     PyDoc_STR("(MusicComponent mc, long part) -> (ComponentResult _rv)")},
    {"MusicStorePartInstrument", (PyCFunction)Qt_MusicStorePartInstrument, 1,
     PyDoc_STR("(MusicComponent mc, long part, long instrumentNumber) -> (ComponentResult _rv)")},
    {"MusicGetPartAtomicInstrument", (PyCFunction)Qt_MusicGetPartAtomicInstrument, 1,
     PyDoc_STR("(MusicComponent mc, long part, long flags) -> (ComponentResult _rv, AtomicInstrument ai)")},
    {"MusicSetPartAtomicInstrument", (PyCFunction)Qt_MusicSetPartAtomicInstrument, 1,
     PyDoc_STR("(MusicComponent mc, long part, AtomicInstrumentPtr aiP, long flags) -> (ComponentResult _rv)")},
    {"MusicGetPartKnob", (PyCFunction)Qt_MusicGetPartKnob, 1,
     PyDoc_STR("(MusicComponent mc, long part, long knobID) -> (ComponentResult _rv)")},
    {"MusicSetPartKnob", (PyCFunction)Qt_MusicSetPartKnob, 1,
     PyDoc_STR("(MusicComponent mc, long part, long knobID, long knobValue) -> (ComponentResult _rv)")},
    {"MusicGetKnob", (PyCFunction)Qt_MusicGetKnob, 1,
     PyDoc_STR("(MusicComponent mc, long knobID) -> (ComponentResult _rv)")},
    {"MusicSetKnob", (PyCFunction)Qt_MusicSetKnob, 1,
     PyDoc_STR("(MusicComponent mc, long knobID, long knobValue) -> (ComponentResult _rv)")},
    {"MusicGetPartName", (PyCFunction)Qt_MusicGetPartName, 1,
     PyDoc_STR("(MusicComponent mc, long part, StringPtr name) -> (ComponentResult _rv)")},
    {"MusicSetPartName", (PyCFunction)Qt_MusicSetPartName, 1,
     PyDoc_STR("(MusicComponent mc, long part, StringPtr name) -> (ComponentResult _rv)")},
    {"MusicPlayNote", (PyCFunction)Qt_MusicPlayNote, 1,
     PyDoc_STR("(MusicComponent mc, long part, long pitch, long velocity) -> (ComponentResult _rv)")},
    {"MusicResetPart", (PyCFunction)Qt_MusicResetPart, 1,
     PyDoc_STR("(MusicComponent mc, long part) -> (ComponentResult _rv)")},
    {"MusicSetPartController", (PyCFunction)Qt_MusicSetPartController, 1,
     PyDoc_STR("(MusicComponent mc, long part, MusicController controllerNumber, long controllerValue) -> (ComponentResult _rv)")},
    {"MusicGetPartController", (PyCFunction)Qt_MusicGetPartController, 1,
     PyDoc_STR("(MusicComponent mc, long part, MusicController controllerNumber) -> (ComponentResult _rv)")},
    {"MusicGetInstrumentNames", (PyCFunction)Qt_MusicGetInstrumentNames, 1,
     PyDoc_STR("(MusicComponent mc, long modifiableInstruments) -> (ComponentResult _rv, Handle instrumentNames, Handle instrumentCategoryLasts, Handle instrumentCategoryNames)")},
    {"MusicGetDrumNames", (PyCFunction)Qt_MusicGetDrumNames, 1,
     PyDoc_STR("(MusicComponent mc, long modifiableInstruments) -> (ComponentResult _rv, Handle instrumentNumbers, Handle instrumentNames)")},
    {"MusicGetMasterTune", (PyCFunction)Qt_MusicGetMasterTune, 1,
     PyDoc_STR("(MusicComponent mc) -> (ComponentResult _rv)")},
    {"MusicSetMasterTune", (PyCFunction)Qt_MusicSetMasterTune, 1,
     PyDoc_STR("(MusicComponent mc, long masterTune) -> (ComponentResult _rv)")},
    {"MusicGetDeviceConnection", (PyCFunction)Qt_MusicGetDeviceConnection, 1,
     PyDoc_STR("(MusicComponent mc, long index) -> (ComponentResult _rv, long id1, long id2)")},
    {"MusicUseDeviceConnection", (PyCFunction)Qt_MusicUseDeviceConnection, 1,
     PyDoc_STR("(MusicComponent mc, long id1, long id2) -> (ComponentResult _rv)")},
    {"MusicGetKnobSettingStrings", (PyCFunction)Qt_MusicGetKnobSettingStrings, 1,
     PyDoc_STR("(MusicComponent mc, long knobIndex, long isGlobal) -> (ComponentResult _rv, Handle settingsNames, Handle settingsCategoryLasts, Handle settingsCategoryNames)")},
    {"MusicGetMIDIPorts", (PyCFunction)Qt_MusicGetMIDIPorts, 1,
     PyDoc_STR("(MusicComponent mc) -> (ComponentResult _rv, long inputPortCount, long outputPortCount)")},
    {"MusicSendMIDI", (PyCFunction)Qt_MusicSendMIDI, 1,
     PyDoc_STR("(MusicComponent mc, long portIndex, MusicMIDIPacket mp) -> (ComponentResult _rv)")},
    {"MusicSetOfflineTimeTo", (PyCFunction)Qt_MusicSetOfflineTimeTo, 1,
     PyDoc_STR("(MusicComponent mc, long newTimeStamp) -> (ComponentResult _rv)")},
    {"MusicGetInfoText", (PyCFunction)Qt_MusicGetInfoText, 1,
     PyDoc_STR("(MusicComponent mc, long selector) -> (ComponentResult _rv, Handle textH, Handle styleH)")},
    {"MusicGetInstrumentInfo", (PyCFunction)Qt_MusicGetInstrumentInfo, 1,
     PyDoc_STR("(MusicComponent mc, long getInstrumentInfoFlags) -> (ComponentResult _rv, InstrumentInfoListHandle infoListH)")},
    {"MusicTask", (PyCFunction)Qt_MusicTask, 1,
     PyDoc_STR("(MusicComponent mc) -> (ComponentResult _rv)")},
    {"MusicSetPartInstrumentNumberInterruptSafe", (PyCFunction)Qt_MusicSetPartInstrumentNumberInterruptSafe, 1,
     PyDoc_STR("(MusicComponent mc, long part, long instrumentNumber) -> (ComponentResult _rv)")},
    {"MusicSetPartSoundLocalization", (PyCFunction)Qt_MusicSetPartSoundLocalization, 1,
     PyDoc_STR("(MusicComponent mc, long part, Handle data) -> (ComponentResult _rv)")},
    {"MusicGenericConfigure", (PyCFunction)Qt_MusicGenericConfigure, 1,
     PyDoc_STR("(MusicComponent mc, long mode, long flags, long baseResID) -> (ComponentResult _rv)")},
    {"MusicGenericGetKnobList", (PyCFunction)Qt_MusicGenericGetKnobList, 1,
     PyDoc_STR("(MusicComponent mc, long knobType) -> (ComponentResult _rv, GenericKnobDescriptionListHandle gkdlH)")},
    {"MusicGenericSetResourceNumbers", (PyCFunction)Qt_MusicGenericSetResourceNumbers, 1,
     PyDoc_STR("(MusicComponent mc, Handle resourceIDH) -> (ComponentResult _rv)")},
    {"MusicDerivedMIDISend", (PyCFunction)Qt_MusicDerivedMIDISend, 1,
     PyDoc_STR("(MusicComponent mc, MusicMIDIPacket packet) -> (ComponentResult _rv)")},
    {"MusicDerivedOpenResFile", (PyCFunction)Qt_MusicDerivedOpenResFile, 1,
     PyDoc_STR("(MusicComponent mc) -> (ComponentResult _rv)")},
    {"MusicDerivedCloseResFile", (PyCFunction)Qt_MusicDerivedCloseResFile, 1,
     PyDoc_STR("(MusicComponent mc, short resRefNum) -> (ComponentResult _rv)")},
    {"NAUnregisterMusicDevice", (PyCFunction)Qt_NAUnregisterMusicDevice, 1,
     PyDoc_STR("(NoteAllocator na, long index) -> (ComponentResult _rv)")},
    {"NASaveMusicConfiguration", (PyCFunction)Qt_NASaveMusicConfiguration, 1,
     PyDoc_STR("(NoteAllocator na) -> (ComponentResult _rv)")},
    {"NAGetMIDIPorts", (PyCFunction)Qt_NAGetMIDIPorts, 1,
     PyDoc_STR("(NoteAllocator na) -> (ComponentResult _rv, QTMIDIPortListHandle inputPorts, QTMIDIPortListHandle outputPorts)")},
    {"NATask", (PyCFunction)Qt_NATask, 1,
     PyDoc_STR("(NoteAllocator na) -> (ComponentResult _rv)")},
    {"TuneSetHeader", (PyCFunction)Qt_TuneSetHeader, 1,
     PyDoc_STR("(TunePlayer tp, unsigned long * header) -> (ComponentResult _rv)")},
    {"TuneGetTimeBase", (PyCFunction)Qt_TuneGetTimeBase, 1,
     PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv, TimeBase tb)")},
    {"TuneSetTimeScale", (PyCFunction)Qt_TuneSetTimeScale, 1,
     PyDoc_STR("(TunePlayer tp, TimeScale scale) -> (ComponentResult _rv)")},
    {"TuneGetTimeScale", (PyCFunction)Qt_TuneGetTimeScale, 1,
     PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv, TimeScale scale)")},
    {"TuneInstant", (PyCFunction)Qt_TuneInstant, 1,
     PyDoc_STR("(TunePlayer tp, unsigned long tunePosition) -> (ComponentResult _rv, unsigned long tune)")},
    {"TuneStop", (PyCFunction)Qt_TuneStop, 1,
     PyDoc_STR("(TunePlayer tp, long stopFlags) -> (ComponentResult _rv)")},
    {"TuneSetVolume", (PyCFunction)Qt_TuneSetVolume, 1,
     PyDoc_STR("(TunePlayer tp, Fixed volume) -> (ComponentResult _rv)")},
    {"TuneGetVolume", (PyCFunction)Qt_TuneGetVolume, 1,
     PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv)")},
    {"TunePreroll", (PyCFunction)Qt_TunePreroll, 1,
     PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv)")},
    {"TuneUnroll", (PyCFunction)Qt_TuneUnroll, 1,
     PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv)")},
    {"TuneSetPartTranspose", (PyCFunction)Qt_TuneSetPartTranspose, 1,
     PyDoc_STR("(TunePlayer tp, unsigned long part, long transpose, long velocityShift) -> (ComponentResult _rv)")},
    {"TuneGetNoteAllocator", (PyCFunction)Qt_TuneGetNoteAllocator, 1,
     PyDoc_STR("(TunePlayer tp) -> (NoteAllocator _rv)")},
    {"TuneSetSofter", (PyCFunction)Qt_TuneSetSofter, 1,
     PyDoc_STR("(TunePlayer tp, long softer) -> (ComponentResult _rv)")},
    {"TuneTask", (PyCFunction)Qt_TuneTask, 1,
     PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv)")},
    {"TuneSetBalance", (PyCFunction)Qt_TuneSetBalance, 1,
     PyDoc_STR("(TunePlayer tp, long balance) -> (ComponentResult _rv)")},
    {"TuneSetSoundLocalization", (PyCFunction)Qt_TuneSetSoundLocalization, 1,
     PyDoc_STR("(TunePlayer tp, Handle data) -> (ComponentResult _rv)")},
    {"TuneSetHeaderWithSize", (PyCFunction)Qt_TuneSetHeaderWithSize, 1,
     PyDoc_STR("(TunePlayer tp, unsigned long * header, unsigned long size) -> (ComponentResult _rv)")},
    {"TuneSetPartMix", (PyCFunction)Qt_TuneSetPartMix, 1,
     PyDoc_STR("(TunePlayer tp, unsigned long partNumber, long volume, long balance, long mixFlags) -> (ComponentResult _rv)")},
    {"TuneGetPartMix", (PyCFunction)Qt_TuneGetPartMix, 1,
     PyDoc_STR("(TunePlayer tp, unsigned long partNumber) -> (ComponentResult _rv, long volumeOut, long balanceOut, long mixFlagsOut)")},
    {"AlignWindow", (PyCFunction)Qt_AlignWindow, 1,
     PyDoc_STR("(WindowPtr wp, Boolean front) -> None")},
    {"DragAlignedWindow", (PyCFunction)Qt_DragAlignedWindow, 1,
     PyDoc_STR("(WindowPtr wp, Point startPt, Rect boundsRect) -> None")},
    {"MoviesTask", (PyCFunction)Qt_MoviesTask, 1,
     PyDoc_STR("(long maxMilliSecToUse) -> None")},
#endif /* APPLE_SUPPORTS_QUICKTIME */
    {NULL, NULL, 0}
};




void init_Qt(void)
{
    PyObject *m;
#if APPLE_SUPPORTS_QUICKTIME
    PyObject *d;



        PyMac_INIT_TOOLBOX_OBJECT_NEW(Track, TrackObj_New);
        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Track, TrackObj_Convert);
        PyMac_INIT_TOOLBOX_OBJECT_NEW(Movie, MovieObj_New);
        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Movie, MovieObj_Convert);
        PyMac_INIT_TOOLBOX_OBJECT_NEW(MovieController, MovieCtlObj_New);
        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(MovieController, MovieCtlObj_Convert);
        PyMac_INIT_TOOLBOX_OBJECT_NEW(TimeBase, TimeBaseObj_New);
        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(TimeBase, TimeBaseObj_Convert);
        PyMac_INIT_TOOLBOX_OBJECT_NEW(UserData, UserDataObj_New);
        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(UserData, UserDataObj_Convert);
        PyMac_INIT_TOOLBOX_OBJECT_NEW(Media, MediaObj_New);
        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Media, MediaObj_Convert);
#endif /* APPLE_SUPPORTS_QUICKTIME */


    m = Py_InitModule("_Qt", Qt_methods);
#if APPLE_SUPPORTS_QUICKTIME
    d = PyModule_GetDict(m);
    Qt_Error = PyMac_GetOSErrException();
    if (Qt_Error == NULL ||
        PyDict_SetItemString(d, "Error", Qt_Error) != 0)
        return;
    IdleManager_Type.ob_type = &PyType_Type;
    if (PyType_Ready(&IdleManager_Type) < 0) return;
    Py_INCREF(&IdleManager_Type);
    PyModule_AddObject(m, "IdleManager", (PyObject *)&IdleManager_Type);
    /* Backward-compatible name */
    Py_INCREF(&IdleManager_Type);
    PyModule_AddObject(m, "IdleManagerType", (PyObject *)&IdleManager_Type);
    MovieController_Type.ob_type = &PyType_Type;
    if (PyType_Ready(&MovieController_Type) < 0) return;
    Py_INCREF(&MovieController_Type);
    PyModule_AddObject(m, "MovieController", (PyObject *)&MovieController_Type);
    /* Backward-compatible name */
    Py_INCREF(&MovieController_Type);
    PyModule_AddObject(m, "MovieControllerType", (PyObject *)&MovieController_Type);
    TimeBase_Type.ob_type = &PyType_Type;
    if (PyType_Ready(&TimeBase_Type) < 0) return;
    Py_INCREF(&TimeBase_Type);
    PyModule_AddObject(m, "TimeBase", (PyObject *)&TimeBase_Type);
    /* Backward-compatible name */
    Py_INCREF(&TimeBase_Type);
    PyModule_AddObject(m, "TimeBaseType", (PyObject *)&TimeBase_Type);
    UserData_Type.ob_type = &PyType_Type;
    if (PyType_Ready(&UserData_Type) < 0) return;
    Py_INCREF(&UserData_Type);
    PyModule_AddObject(m, "UserData", (PyObject *)&UserData_Type);
    /* Backward-compatible name */
    Py_INCREF(&UserData_Type);
    PyModule_AddObject(m, "UserDataType", (PyObject *)&UserData_Type);
    Media_Type.ob_type = &PyType_Type;
    if (PyType_Ready(&Media_Type) < 0) return;
    Py_INCREF(&Media_Type);
    PyModule_AddObject(m, "Media", (PyObject *)&Media_Type);
    /* Backward-compatible name */
    Py_INCREF(&Media_Type);
    PyModule_AddObject(m, "MediaType", (PyObject *)&Media_Type);
    Track_Type.ob_type = &PyType_Type;
    if (PyType_Ready(&Track_Type) < 0) return;
    Py_INCREF(&Track_Type);
    PyModule_AddObject(m, "Track", (PyObject *)&Track_Type);
    /* Backward-compatible name */
    Py_INCREF(&Track_Type);
    PyModule_AddObject(m, "TrackType", (PyObject *)&Track_Type);
    Movie_Type.ob_type = &PyType_Type;
    if (PyType_Ready(&Movie_Type) < 0) return;
    Py_INCREF(&Movie_Type);
    PyModule_AddObject(m, "Movie", (PyObject *)&Movie_Type);
    /* Backward-compatible name */
    Py_INCREF(&Movie_Type);
    PyModule_AddObject(m, "MovieType", (PyObject *)&Movie_Type);
    SGOutput_Type.ob_type = &PyType_Type;
    if (PyType_Ready(&SGOutput_Type) < 0) return;
    Py_INCREF(&SGOutput_Type);
    PyModule_AddObject(m, "SGOutput", (PyObject *)&SGOutput_Type);
    /* Backward-compatible name */
    Py_INCREF(&SGOutput_Type);
    PyModule_AddObject(m, "SGOutputType", (PyObject *)&SGOutput_Type);
#endif /* APPLE_SUPPORTS_QUICKTIME */
}

/* ========================= End module _Qt ========================= */

