--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/qt/_Qtmodule.c Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,28091 @@
+
+/* =========================== Module _Qt =========================== */
+
+#include "Python.h"
+
+
+#ifndef __LP64__
+
+#include "pymactoolbox.h"
+
+/* Macro to test whether a weak-loaded CFM function exists */
+#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
+ PyErr_SetString(PyExc_NotImplementedError, \
+ "Not available in this shared library/OS version"); \
+ return NULL; \
+ }} while(0)
+
+
+#include <QuickTime/QuickTime.h>
+
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+extern PyObject *_TrackObj_New(Track);
+extern int _TrackObj_Convert(PyObject *, Track *);
+extern PyObject *_MovieObj_New(Movie);
+extern int _MovieObj_Convert(PyObject *, Movie *);
+extern PyObject *_MovieCtlObj_New(MovieController);
+extern int _MovieCtlObj_Convert(PyObject *, MovieController *);
+extern PyObject *_TimeBaseObj_New(TimeBase);
+extern int _TimeBaseObj_Convert(PyObject *, TimeBase *);
+extern PyObject *_UserDataObj_New(UserData);
+extern int _UserDataObj_Convert(PyObject *, UserData *);
+extern PyObject *_MediaObj_New(Media);
+extern int _MediaObj_Convert(PyObject *, Media *);
+
+#define TrackObj_New _TrackObj_New
+#define TrackObj_Convert _TrackObj_Convert
+#define MovieObj_New _MovieObj_New
+#define MovieObj_Convert _MovieObj_Convert
+#define MovieCtlObj_New _MovieCtlObj_New
+#define MovieCtlObj_Convert _MovieCtlObj_Convert
+#define TimeBaseObj_New _TimeBaseObj_New
+#define TimeBaseObj_Convert _TimeBaseObj_Convert
+#define UserDataObj_New _UserDataObj_New
+#define UserDataObj_Convert _UserDataObj_Convert
+#define MediaObj_New _MediaObj_New
+#define MediaObj_Convert _MediaObj_Convert
+#endif
+
+/* Macro to allow us to GetNextInterestingTime without duration */
+#define GetMediaNextInterestingTimeOnly(media, flags, time, rate, rv) GetMediaNextInterestingTime(media, flags, time, rate, rv, NULL)
+
+/*
+** Parse/generate time records
+*/
+static PyObject *
+QtTimeRecord_New(TimeRecord *itself)
+{
+ if (itself->base)
+ return Py_BuildValue("O&lO&", PyMac_Buildwide, &itself->value, itself->scale,
+ TimeBaseObj_New, itself->base);
+ else
+ return Py_BuildValue("O&lO", PyMac_Buildwide, &itself->value, itself->scale,
+ Py_None);
+}
+
+static int
+QtTimeRecord_Convert(PyObject *v, TimeRecord *p_itself)
+{
+ PyObject *base = NULL;
+ if( !PyArg_ParseTuple(v, "O&l|O", PyMac_Getwide, &p_itself->value, &p_itself->scale,
+ &base) )
+ return 0;
+ if ( base == NULL || base == Py_None )
+ p_itself->base = NULL;
+ else
+ if ( !TimeBaseObj_Convert(base, &p_itself->base) )
+ return 0;
+ return 1;
+}
+
+static int
+QtMusicMIDIPacket_Convert(PyObject *v, MusicMIDIPacket *p_itself)
+{
+ int dummy;
+
+ if( !PyArg_ParseTuple(v, "hls#", &p_itself->length, &p_itself->reserved, p_itself->data, dummy) )
+ return 0;
+ return 1;
+}
+
+
+
+
+static PyObject *Qt_Error;
+
+/* -------------------- Object type IdleManager --------------------- */
+
+PyTypeObject IdleManager_Type;
+
+#define IdleManagerObj_Check(x) ((x)->ob_type == &IdleManager_Type || PyObject_TypeCheck((x), &IdleManager_Type))
+
+typedef struct IdleManagerObject {
+ PyObject_HEAD
+ IdleManager ob_itself;
+} IdleManagerObject;
+
+PyObject *IdleManagerObj_New(IdleManager itself)
+{
+ IdleManagerObject *it;
+ if (itself == NULL) {
+ PyErr_SetString(Qt_Error,"Cannot create IdleManager from NULL pointer");
+ return NULL;
+ }
+ it = PyObject_NEW(IdleManagerObject, &IdleManager_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+
+int IdleManagerObj_Convert(PyObject *v, IdleManager *p_itself)
+{
+ if (v == Py_None)
+ {
+ *p_itself = NULL;
+ return 1;
+ }
+ if (!IdleManagerObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "IdleManager required");
+ return 0;
+ }
+ *p_itself = ((IdleManagerObject *)v)->ob_itself;
+ return 1;
+}
+
+static void IdleManagerObj_dealloc(IdleManagerObject *self)
+{
+ /* Cleanup of self->ob_itself goes here */
+ self->ob_type->tp_free((PyObject *)self);
+}
+
+static PyMethodDef IdleManagerObj_methods[] = {
+ {NULL, NULL, 0}
+};
+
+#define IdleManagerObj_getsetlist NULL
+
+
+#define IdleManagerObj_compare NULL
+
+#define IdleManagerObj_repr NULL
+
+#define IdleManagerObj_hash NULL
+#define IdleManagerObj_tp_init 0
+
+#define IdleManagerObj_tp_alloc PyType_GenericAlloc
+
+static PyObject *IdleManagerObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
+{
+ PyObject *_self;
+ IdleManager itself;
+ char *kw[] = {"itself", 0};
+
+ if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, IdleManagerObj_Convert, &itself)) return NULL;
+ if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
+ ((IdleManagerObject *)_self)->ob_itself = itself;
+ return _self;
+}
+
+#define IdleManagerObj_tp_free PyObject_Del
+
+
+PyTypeObject IdleManager_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0, /*ob_size*/
+ "_Qt.IdleManager", /*tp_name*/
+ sizeof(IdleManagerObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) IdleManagerObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc)0, /*tp_getattr*/
+ (setattrfunc)0, /*tp_setattr*/
+ (cmpfunc) IdleManagerObj_compare, /*tp_compare*/
+ (reprfunc) IdleManagerObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) IdleManagerObj_hash, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ PyObject_GenericGetAttr, /*tp_getattro*/
+ PyObject_GenericSetAttr, /*tp_setattro */
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
+ 0, /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ 0, /*tp_iter*/
+ 0, /*tp_iternext*/
+ IdleManagerObj_methods, /* tp_methods */
+ 0, /*tp_members*/
+ IdleManagerObj_getsetlist, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ IdleManagerObj_tp_init, /* tp_init */
+ IdleManagerObj_tp_alloc, /* tp_alloc */
+ IdleManagerObj_tp_new, /* tp_new */
+ IdleManagerObj_tp_free, /* tp_free */
+};
+
+/* ------------------ End object type IdleManager ------------------- */
+
+
+/* ------------------ Object type MovieController ------------------- */
+
+PyTypeObject MovieController_Type;
+
+#define MovieCtlObj_Check(x) ((x)->ob_type == &MovieController_Type || PyObject_TypeCheck((x), &MovieController_Type))
+
+typedef struct MovieControllerObject {
+ PyObject_HEAD
+ MovieController ob_itself;
+} MovieControllerObject;
+
+PyObject *MovieCtlObj_New(MovieController itself)
+{
+ MovieControllerObject *it;
+ if (itself == NULL) {
+ PyErr_SetString(Qt_Error,"Cannot create MovieController from NULL pointer");
+ return NULL;
+ }
+ it = PyObject_NEW(MovieControllerObject, &MovieController_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+
+int MovieCtlObj_Convert(PyObject *v, MovieController *p_itself)
+{
+ if (v == Py_None)
+ {
+ *p_itself = NULL;
+ return 1;
+ }
+ if (!MovieCtlObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "MovieController required");
+ return 0;
+ }
+ *p_itself = ((MovieControllerObject *)v)->ob_itself;
+ return 1;
+}
+
+static void MovieCtlObj_dealloc(MovieControllerObject *self)
+{
+ if (self->ob_itself) DisposeMovieController(self->ob_itself);
+ self->ob_type->tp_free((PyObject *)self);
+}
+
+static PyObject *MovieCtlObj_MCSetMovie(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Movie theMovie;
+ WindowPtr movieWindow;
+ Point where;
+#ifndef MCSetMovie
+ PyMac_PRECHECK(MCSetMovie);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ MovieObj_Convert, &theMovie,
+ WinObj_Convert, &movieWindow,
+ PyMac_GetPoint, &where))
+ return NULL;
+ _rv = MCSetMovie(_self->ob_itself,
+ theMovie,
+ movieWindow,
+ where);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCGetIndMovie(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Movie _rv;
+ short index;
+#ifndef MCGetIndMovie
+ PyMac_PRECHECK(MCGetIndMovie);
+#endif
+ if (!PyArg_ParseTuple(_args, "h",
+ &index))
+ return NULL;
+ _rv = MCGetIndMovie(_self->ob_itself,
+ index);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCRemoveAllMovies(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+#ifndef MCRemoveAllMovies
+ PyMac_PRECHECK(MCRemoveAllMovies);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCRemoveAllMovies(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCRemoveAMovie(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Movie m;
+#ifndef MCRemoveAMovie
+ PyMac_PRECHECK(MCRemoveAMovie);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ MovieObj_Convert, &m))
+ return NULL;
+ _rv = MCRemoveAMovie(_self->ob_itself,
+ m);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCRemoveMovie(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+#ifndef MCRemoveMovie
+ PyMac_PRECHECK(MCRemoveMovie);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCRemoveMovie(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCIsPlayerEvent(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ EventRecord e;
+#ifndef MCIsPlayerEvent
+ PyMac_PRECHECK(MCIsPlayerEvent);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &e))
+ return NULL;
+ _rv = MCIsPlayerEvent(_self->ob_itself,
+ &e);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCDoAction(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ short action;
+ void * params;
+#ifndef MCDoAction
+ PyMac_PRECHECK(MCDoAction);
+#endif
+ if (!PyArg_ParseTuple(_args, "hs",
+ &action,
+ ¶ms))
+ 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, ©Rule))
+ 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, ©Rule))
+ 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, ©Rule))
+ 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,
+ ¤tTime);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ QtTimeRecord_New, ¤tTime);
+ 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, ©Rule))
+ 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,
+ ¶ms))
+ 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, ¶meterID,
+ ¶meterChangeSeed,
+ &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, ¶meterID,
+ 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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_Convert, &ci,
+ CmpObj_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&",
+ CmpObj_Convert, &ci))
+ return NULL;
+ _rv = GraphicsExportGetInputGraphicsImporter(ci,
+ &grip);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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,
+ ¬SyncFlag);
+ _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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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,
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_Convert, &s,
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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&",
+ CmpObj_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",
+ CmpObj_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&",
+ CmpObj_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 /* __LP64__ */
+
+static PyMethodDef Qt_methods[] = {
+#ifndef __LP64__
+ {"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 /* __LP64__ */
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_Qt(void)
+{
+ PyObject *m;
+#ifndef __LP64__
+ 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 /* __LP64__ */
+
+
+ m = Py_InitModule("_Qt", Qt_methods);
+#ifndef __LP64__
+ 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 /* __LP64__ */
+}
+
+/* ========================= End module _Qt ========================= */
+