mirror of
https://github.com/python/cpython.git
synced 2025-10-31 05:31:20 +00:00
9d79990ac7
Should finally fix 531398. 2.2.1 candidate. Also blacklisted some constants with definitions that were not Python-compatible.
9934 lines
288 KiB
C
9934 lines
288 KiB
C
|
|
/* =========================== Module _Qt =========================== */
|
|
|
|
#include "Python.h"
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
#include "pywintoolbox.h"
|
|
#else
|
|
#include "macglue.h"
|
|
#include "pymactoolbox.h"
|
|
#endif
|
|
|
|
/* 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)
|
|
|
|
|
|
#ifdef WITHOUT_FRAMEWORKS
|
|
#include <Movies.h>
|
|
#else
|
|
/* #include <Carbon/Carbon.h> */
|
|
#include <QuickTime/QuickTime.h>
|
|
#endif
|
|
|
|
|
|
#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 PyObject *Qt_Error;
|
|
|
|
/* ------------------ Object type MovieController ------------------- */
|
|
|
|
PyTypeObject MovieController_Type;
|
|
|
|
#define MovieCtlObj_Check(x) ((x)->ob_type == &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 null MovieController");
|
|
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 (!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)
|
|
{
|
|
DisposeMovieController(self->ob_itself);
|
|
PyMem_DEL(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 PyMethodDef MovieCtlObj_methods[] = {
|
|
{"MCSetMovie", (PyCFunction)MovieCtlObj_MCSetMovie, 1,
|
|
"(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)"},
|
|
{"MCGetIndMovie", (PyCFunction)MovieCtlObj_MCGetIndMovie, 1,
|
|
"(short index) -> (Movie _rv)"},
|
|
{"MCRemoveAllMovies", (PyCFunction)MovieCtlObj_MCRemoveAllMovies, 1,
|
|
"() -> (ComponentResult _rv)"},
|
|
{"MCRemoveAMovie", (PyCFunction)MovieCtlObj_MCRemoveAMovie, 1,
|
|
"(Movie m) -> (ComponentResult _rv)"},
|
|
{"MCRemoveMovie", (PyCFunction)MovieCtlObj_MCRemoveMovie, 1,
|
|
"() -> (ComponentResult _rv)"},
|
|
{"MCIsPlayerEvent", (PyCFunction)MovieCtlObj_MCIsPlayerEvent, 1,
|
|
"(EventRecord e) -> (ComponentResult _rv)"},
|
|
{"MCDoAction", (PyCFunction)MovieCtlObj_MCDoAction, 1,
|
|
"(short action, void * params) -> (ComponentResult _rv)"},
|
|
{"MCSetControllerAttached", (PyCFunction)MovieCtlObj_MCSetControllerAttached, 1,
|
|
"(Boolean attach) -> (ComponentResult _rv)"},
|
|
{"MCIsControllerAttached", (PyCFunction)MovieCtlObj_MCIsControllerAttached, 1,
|
|
"() -> (ComponentResult _rv)"},
|
|
{"MCSetControllerPort", (PyCFunction)MovieCtlObj_MCSetControllerPort, 1,
|
|
"(CGrafPtr gp) -> (ComponentResult _rv)"},
|
|
{"MCGetControllerPort", (PyCFunction)MovieCtlObj_MCGetControllerPort, 1,
|
|
"() -> (CGrafPtr _rv)"},
|
|
{"MCSetVisible", (PyCFunction)MovieCtlObj_MCSetVisible, 1,
|
|
"(Boolean visible) -> (ComponentResult _rv)"},
|
|
{"MCGetVisible", (PyCFunction)MovieCtlObj_MCGetVisible, 1,
|
|
"() -> (ComponentResult _rv)"},
|
|
{"MCGetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRect, 1,
|
|
"() -> (ComponentResult _rv, Rect bounds)"},
|
|
{"MCSetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCSetControllerBoundsRect, 1,
|
|
"(Rect bounds) -> (ComponentResult _rv)"},
|
|
{"MCGetControllerBoundsRgn", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRgn, 1,
|
|
"() -> (RgnHandle _rv)"},
|
|
{"MCGetWindowRgn", (PyCFunction)MovieCtlObj_MCGetWindowRgn, 1,
|
|
"(WindowPtr w) -> (RgnHandle _rv)"},
|
|
{"MCMovieChanged", (PyCFunction)MovieCtlObj_MCMovieChanged, 1,
|
|
"(Movie m) -> (ComponentResult _rv)"},
|
|
{"MCSetDuration", (PyCFunction)MovieCtlObj_MCSetDuration, 1,
|
|
"(TimeValue duration) -> (ComponentResult _rv)"},
|
|
{"MCGetCurrentTime", (PyCFunction)MovieCtlObj_MCGetCurrentTime, 1,
|
|
"() -> (TimeValue _rv, TimeScale scale)"},
|
|
{"MCNewAttachedController", (PyCFunction)MovieCtlObj_MCNewAttachedController, 1,
|
|
"(Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)"},
|
|
{"MCDraw", (PyCFunction)MovieCtlObj_MCDraw, 1,
|
|
"(WindowPtr w) -> (ComponentResult _rv)"},
|
|
{"MCActivate", (PyCFunction)MovieCtlObj_MCActivate, 1,
|
|
"(WindowPtr w, Boolean activate) -> (ComponentResult _rv)"},
|
|
{"MCIdle", (PyCFunction)MovieCtlObj_MCIdle, 1,
|
|
"() -> (ComponentResult _rv)"},
|
|
{"MCKey", (PyCFunction)MovieCtlObj_MCKey, 1,
|
|
"(SInt8 key, long modifiers) -> (ComponentResult _rv)"},
|
|
{"MCClick", (PyCFunction)MovieCtlObj_MCClick, 1,
|
|
"(WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)"},
|
|
{"MCEnableEditing", (PyCFunction)MovieCtlObj_MCEnableEditing, 1,
|
|
"(Boolean enabled) -> (ComponentResult _rv)"},
|
|
{"MCIsEditingEnabled", (PyCFunction)MovieCtlObj_MCIsEditingEnabled, 1,
|
|
"() -> (long _rv)"},
|
|
{"MCCopy", (PyCFunction)MovieCtlObj_MCCopy, 1,
|
|
"() -> (Movie _rv)"},
|
|
{"MCCut", (PyCFunction)MovieCtlObj_MCCut, 1,
|
|
"() -> (Movie _rv)"},
|
|
{"MCPaste", (PyCFunction)MovieCtlObj_MCPaste, 1,
|
|
"(Movie srcMovie) -> (ComponentResult _rv)"},
|
|
{"MCClear", (PyCFunction)MovieCtlObj_MCClear, 1,
|
|
"() -> (ComponentResult _rv)"},
|
|
{"MCUndo", (PyCFunction)MovieCtlObj_MCUndo, 1,
|
|
"() -> (ComponentResult _rv)"},
|
|
{"MCPositionController", (PyCFunction)MovieCtlObj_MCPositionController, 1,
|
|
"(Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)"},
|
|
{"MCGetControllerInfo", (PyCFunction)MovieCtlObj_MCGetControllerInfo, 1,
|
|
"() -> (ComponentResult _rv, long someFlags)"},
|
|
{"MCSetClip", (PyCFunction)MovieCtlObj_MCSetClip, 1,
|
|
"(RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)"},
|
|
{"MCGetClip", (PyCFunction)MovieCtlObj_MCGetClip, 1,
|
|
"() -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)"},
|
|
{"MCDrawBadge", (PyCFunction)MovieCtlObj_MCDrawBadge, 1,
|
|
"(RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)"},
|
|
{"MCSetUpEditMenu", (PyCFunction)MovieCtlObj_MCSetUpEditMenu, 1,
|
|
"(long modifiers, MenuHandle mh) -> (ComponentResult _rv)"},
|
|
{"MCGetMenuString", (PyCFunction)MovieCtlObj_MCGetMenuString, 1,
|
|
"(long modifiers, short item, Str255 aString) -> (ComponentResult _rv)"},
|
|
{"MCPtInController", (PyCFunction)MovieCtlObj_MCPtInController, 1,
|
|
"(Point thePt) -> (ComponentResult _rv, Boolean inController)"},
|
|
{"MCInvalidate", (PyCFunction)MovieCtlObj_MCInvalidate, 1,
|
|
"(WindowPtr w, RgnHandle invalidRgn) -> (ComponentResult _rv)"},
|
|
{"MCAdjustCursor", (PyCFunction)MovieCtlObj_MCAdjustCursor, 1,
|
|
"(WindowPtr w, Point where, long modifiers) -> (ComponentResult _rv)"},
|
|
{"MCGetInterfaceElement", (PyCFunction)MovieCtlObj_MCGetInterfaceElement, 1,
|
|
"(MCInterfaceElement whichElement, void * element) -> (ComponentResult _rv)"},
|
|
{"MCAddMovieSegment", (PyCFunction)MovieCtlObj_MCAddMovieSegment, 1,
|
|
"(Movie srcMovie, Boolean scaled) -> (ComponentResult _rv)"},
|
|
{"MCTrimMovieSegment", (PyCFunction)MovieCtlObj_MCTrimMovieSegment, 1,
|
|
"() -> (ComponentResult _rv)"},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
PyMethodChain MovieCtlObj_chain = { MovieCtlObj_methods, NULL };
|
|
|
|
static PyObject *MovieCtlObj_getattr(MovieControllerObject *self, char *name)
|
|
{
|
|
return Py_FindMethodInChain(&MovieCtlObj_chain, (PyObject *)self, name);
|
|
}
|
|
|
|
#define MovieCtlObj_setattr NULL
|
|
|
|
#define MovieCtlObj_compare NULL
|
|
|
|
#define MovieCtlObj_repr NULL
|
|
|
|
#define MovieCtlObj_hash NULL
|
|
|
|
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) MovieCtlObj_getattr, /*tp_getattr*/
|
|
(setattrfunc) MovieCtlObj_setattr, /*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*/
|
|
};
|
|
|
|
/* ---------------- End object type MovieController ----------------- */
|
|
|
|
|
|
/* ---------------------- Object type TimeBase ---------------------- */
|
|
|
|
PyTypeObject TimeBase_Type;
|
|
|
|
#define TimeBaseObj_Check(x) ((x)->ob_type == &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 null TimeBase");
|
|
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 (!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 */
|
|
PyMem_DEL(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,
|
|
"() -> None"},
|
|
{"GetTimeBaseTime", (PyCFunction)TimeBaseObj_GetTimeBaseTime, 1,
|
|
"(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"},
|
|
{"SetTimeBaseTime", (PyCFunction)TimeBaseObj_SetTimeBaseTime, 1,
|
|
"(TimeRecord tr) -> None"},
|
|
{"SetTimeBaseValue", (PyCFunction)TimeBaseObj_SetTimeBaseValue, 1,
|
|
"(TimeValue t, TimeScale s) -> None"},
|
|
{"GetTimeBaseRate", (PyCFunction)TimeBaseObj_GetTimeBaseRate, 1,
|
|
"() -> (Fixed _rv)"},
|
|
{"SetTimeBaseRate", (PyCFunction)TimeBaseObj_SetTimeBaseRate, 1,
|
|
"(Fixed r) -> None"},
|
|
{"GetTimeBaseStartTime", (PyCFunction)TimeBaseObj_GetTimeBaseStartTime, 1,
|
|
"(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"},
|
|
{"SetTimeBaseStartTime", (PyCFunction)TimeBaseObj_SetTimeBaseStartTime, 1,
|
|
"(TimeRecord tr) -> None"},
|
|
{"GetTimeBaseStopTime", (PyCFunction)TimeBaseObj_GetTimeBaseStopTime, 1,
|
|
"(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"},
|
|
{"SetTimeBaseStopTime", (PyCFunction)TimeBaseObj_SetTimeBaseStopTime, 1,
|
|
"(TimeRecord tr) -> None"},
|
|
{"GetTimeBaseFlags", (PyCFunction)TimeBaseObj_GetTimeBaseFlags, 1,
|
|
"() -> (long _rv)"},
|
|
{"SetTimeBaseFlags", (PyCFunction)TimeBaseObj_SetTimeBaseFlags, 1,
|
|
"(long timeBaseFlags) -> None"},
|
|
{"SetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_SetTimeBaseMasterTimeBase, 1,
|
|
"(TimeBase master, TimeRecord slaveZero) -> None"},
|
|
{"GetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_GetTimeBaseMasterTimeBase, 1,
|
|
"() -> (TimeBase _rv)"},
|
|
{"SetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_SetTimeBaseMasterClock, 1,
|
|
"(Component clockMeister, TimeRecord slaveZero) -> None"},
|
|
{"GetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_GetTimeBaseMasterClock, 1,
|
|
"() -> (ComponentInstance _rv)"},
|
|
{"GetTimeBaseStatus", (PyCFunction)TimeBaseObj_GetTimeBaseStatus, 1,
|
|
"() -> (long _rv, TimeRecord unpinnedTime)"},
|
|
{"SetTimeBaseZero", (PyCFunction)TimeBaseObj_SetTimeBaseZero, 1,
|
|
"(TimeRecord zero) -> None"},
|
|
{"GetTimeBaseEffectiveRate", (PyCFunction)TimeBaseObj_GetTimeBaseEffectiveRate, 1,
|
|
"() -> (Fixed _rv)"},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
PyMethodChain TimeBaseObj_chain = { TimeBaseObj_methods, NULL };
|
|
|
|
static PyObject *TimeBaseObj_getattr(TimeBaseObject *self, char *name)
|
|
{
|
|
return Py_FindMethodInChain(&TimeBaseObj_chain, (PyObject *)self, name);
|
|
}
|
|
|
|
#define TimeBaseObj_setattr NULL
|
|
|
|
#define TimeBaseObj_compare NULL
|
|
|
|
#define TimeBaseObj_repr NULL
|
|
|
|
#define TimeBaseObj_hash NULL
|
|
|
|
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) TimeBaseObj_getattr, /*tp_getattr*/
|
|
(setattrfunc) TimeBaseObj_setattr, /*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*/
|
|
};
|
|
|
|
/* -------------------- End object type TimeBase -------------------- */
|
|
|
|
|
|
/* ---------------------- Object type UserData ---------------------- */
|
|
|
|
PyTypeObject UserData_Type;
|
|
|
|
#define UserDataObj_Check(x) ((x)->ob_type == &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 null UserData");
|
|
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 (!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)
|
|
{
|
|
DisposeUserData(self->ob_itself);
|
|
PyMem_DEL(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 PyMethodDef UserDataObj_methods[] = {
|
|
{"GetUserData", (PyCFunction)UserDataObj_GetUserData, 1,
|
|
"(Handle data, OSType udType, long index) -> None"},
|
|
{"AddUserData", (PyCFunction)UserDataObj_AddUserData, 1,
|
|
"(Handle data, OSType udType) -> None"},
|
|
{"RemoveUserData", (PyCFunction)UserDataObj_RemoveUserData, 1,
|
|
"(OSType udType, long index) -> None"},
|
|
{"CountUserDataType", (PyCFunction)UserDataObj_CountUserDataType, 1,
|
|
"(OSType udType) -> (short _rv)"},
|
|
{"GetNextUserDataType", (PyCFunction)UserDataObj_GetNextUserDataType, 1,
|
|
"(OSType udType) -> (long _rv)"},
|
|
{"AddUserDataText", (PyCFunction)UserDataObj_AddUserDataText, 1,
|
|
"(Handle data, OSType udType, long index, short itlRegionTag) -> None"},
|
|
{"GetUserDataText", (PyCFunction)UserDataObj_GetUserDataText, 1,
|
|
"(Handle data, OSType udType, long index, short itlRegionTag) -> None"},
|
|
{"RemoveUserDataText", (PyCFunction)UserDataObj_RemoveUserDataText, 1,
|
|
"(OSType udType, long index, short itlRegionTag) -> None"},
|
|
{"PutUserDataIntoHandle", (PyCFunction)UserDataObj_PutUserDataIntoHandle, 1,
|
|
"(Handle h) -> None"},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
PyMethodChain UserDataObj_chain = { UserDataObj_methods, NULL };
|
|
|
|
static PyObject *UserDataObj_getattr(UserDataObject *self, char *name)
|
|
{
|
|
return Py_FindMethodInChain(&UserDataObj_chain, (PyObject *)self, name);
|
|
}
|
|
|
|
#define UserDataObj_setattr NULL
|
|
|
|
#define UserDataObj_compare NULL
|
|
|
|
#define UserDataObj_repr NULL
|
|
|
|
#define UserDataObj_hash NULL
|
|
|
|
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) UserDataObj_getattr, /*tp_getattr*/
|
|
(setattrfunc) UserDataObj_setattr, /*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*/
|
|
};
|
|
|
|
/* -------------------- End object type UserData -------------------- */
|
|
|
|
|
|
/* ----------------------- Object type Media ------------------------ */
|
|
|
|
PyTypeObject Media_Type;
|
|
|
|
#define MediaObj_Check(x) ((x)->ob_type == &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 null Media");
|
|
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 (!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)
|
|
{
|
|
DisposeTrackMedia(self->ob_itself);
|
|
PyMem_DEL(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_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,
|
|
"(TimeValue time, TimeValue duration, long flags) -> None"},
|
|
{"GetMediaTrack", (PyCFunction)MediaObj_GetMediaTrack, 1,
|
|
"() -> (Track _rv)"},
|
|
{"GetMediaCreationTime", (PyCFunction)MediaObj_GetMediaCreationTime, 1,
|
|
"() -> (unsigned long _rv)"},
|
|
{"GetMediaModificationTime", (PyCFunction)MediaObj_GetMediaModificationTime, 1,
|
|
"() -> (unsigned long _rv)"},
|
|
{"GetMediaTimeScale", (PyCFunction)MediaObj_GetMediaTimeScale, 1,
|
|
"() -> (TimeScale _rv)"},
|
|
{"SetMediaTimeScale", (PyCFunction)MediaObj_SetMediaTimeScale, 1,
|
|
"(TimeScale timeScale) -> None"},
|
|
{"GetMediaDuration", (PyCFunction)MediaObj_GetMediaDuration, 1,
|
|
"() -> (TimeValue _rv)"},
|
|
{"GetMediaLanguage", (PyCFunction)MediaObj_GetMediaLanguage, 1,
|
|
"() -> (short _rv)"},
|
|
{"SetMediaLanguage", (PyCFunction)MediaObj_SetMediaLanguage, 1,
|
|
"(short language) -> None"},
|
|
{"GetMediaQuality", (PyCFunction)MediaObj_GetMediaQuality, 1,
|
|
"() -> (short _rv)"},
|
|
{"SetMediaQuality", (PyCFunction)MediaObj_SetMediaQuality, 1,
|
|
"(short quality) -> None"},
|
|
{"GetMediaHandlerDescription", (PyCFunction)MediaObj_GetMediaHandlerDescription, 1,
|
|
"(Str255 creatorName) -> (OSType mediaType, OSType creatorManufacturer)"},
|
|
{"GetMediaUserData", (PyCFunction)MediaObj_GetMediaUserData, 1,
|
|
"() -> (UserData _rv)"},
|
|
{"GetMediaHandler", (PyCFunction)MediaObj_GetMediaHandler, 1,
|
|
"() -> (MediaHandler _rv)"},
|
|
{"SetMediaHandler", (PyCFunction)MediaObj_SetMediaHandler, 1,
|
|
"(MediaHandlerComponent mH) -> None"},
|
|
{"BeginMediaEdits", (PyCFunction)MediaObj_BeginMediaEdits, 1,
|
|
"() -> None"},
|
|
{"EndMediaEdits", (PyCFunction)MediaObj_EndMediaEdits, 1,
|
|
"() -> None"},
|
|
{"SetMediaDefaultDataRefIndex", (PyCFunction)MediaObj_SetMediaDefaultDataRefIndex, 1,
|
|
"(short index) -> None"},
|
|
{"GetMediaDataHandlerDescription", (PyCFunction)MediaObj_GetMediaDataHandlerDescription, 1,
|
|
"(short index, Str255 creatorName) -> (OSType dhType, OSType creatorManufacturer)"},
|
|
{"GetMediaDataHandler", (PyCFunction)MediaObj_GetMediaDataHandler, 1,
|
|
"(short index) -> (DataHandler _rv)"},
|
|
{"SetMediaDataHandler", (PyCFunction)MediaObj_SetMediaDataHandler, 1,
|
|
"(short index, DataHandlerComponent dataHandler) -> None"},
|
|
{"GetMediaSampleDescriptionCount", (PyCFunction)MediaObj_GetMediaSampleDescriptionCount, 1,
|
|
"() -> (long _rv)"},
|
|
{"GetMediaSampleDescription", (PyCFunction)MediaObj_GetMediaSampleDescription, 1,
|
|
"(long index, SampleDescriptionHandle descH) -> None"},
|
|
{"SetMediaSampleDescription", (PyCFunction)MediaObj_SetMediaSampleDescription, 1,
|
|
"(long index, SampleDescriptionHandle descH) -> None"},
|
|
{"GetMediaSampleCount", (PyCFunction)MediaObj_GetMediaSampleCount, 1,
|
|
"() -> (long _rv)"},
|
|
{"GetMediaSyncSampleCount", (PyCFunction)MediaObj_GetMediaSyncSampleCount, 1,
|
|
"() -> (long _rv)"},
|
|
{"SampleNumToMediaTime", (PyCFunction)MediaObj_SampleNumToMediaTime, 1,
|
|
"(long logicalSampleNum) -> (TimeValue sampleTime, TimeValue sampleDuration)"},
|
|
{"MediaTimeToSampleNum", (PyCFunction)MediaObj_MediaTimeToSampleNum, 1,
|
|
"(TimeValue time) -> (long sampleNum, TimeValue sampleTime, TimeValue sampleDuration)"},
|
|
{"AddMediaSample", (PyCFunction)MediaObj_AddMediaSample, 1,
|
|
"(Handle dataIn, long inOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)"},
|
|
{"AddMediaSampleReference", (PyCFunction)MediaObj_AddMediaSampleReference, 1,
|
|
"(long dataOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)"},
|
|
{"GetMediaSample", (PyCFunction)MediaObj_GetMediaSample, 1,
|
|
"(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,
|
|
"(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,
|
|
"(long maxChunkSize) -> None"},
|
|
{"GetMediaPreferredChunkSize", (PyCFunction)MediaObj_GetMediaPreferredChunkSize, 1,
|
|
"() -> (long maxChunkSize)"},
|
|
{"SetMediaShadowSync", (PyCFunction)MediaObj_SetMediaShadowSync, 1,
|
|
"(long frameDiffSampleNum, long syncSampleNum) -> None"},
|
|
{"GetMediaShadowSync", (PyCFunction)MediaObj_GetMediaShadowSync, 1,
|
|
"(long frameDiffSampleNum) -> (long syncSampleNum)"},
|
|
{"GetMediaDataSize", (PyCFunction)MediaObj_GetMediaDataSize, 1,
|
|
"(TimeValue startTime, TimeValue duration) -> (long _rv)"},
|
|
{"GetMediaDataSize64", (PyCFunction)MediaObj_GetMediaDataSize64, 1,
|
|
"(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
|
|
{"GetMediaNextInterestingTime", (PyCFunction)MediaObj_GetMediaNextInterestingTime, 1,
|
|
"(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
|
|
{"GetMediaDataRef", (PyCFunction)MediaObj_GetMediaDataRef, 1,
|
|
"(short index) -> (Handle dataRef, OSType dataRefType, long dataRefAttributes)"},
|
|
{"SetMediaDataRef", (PyCFunction)MediaObj_SetMediaDataRef, 1,
|
|
"(short index, Handle dataRef, OSType dataRefType) -> None"},
|
|
{"SetMediaDataRefAttributes", (PyCFunction)MediaObj_SetMediaDataRefAttributes, 1,
|
|
"(short index, long dataRefAttributes) -> None"},
|
|
{"AddMediaDataRef", (PyCFunction)MediaObj_AddMediaDataRef, 1,
|
|
"(Handle dataRef, OSType dataRefType) -> (short index)"},
|
|
{"GetMediaDataRefCount", (PyCFunction)MediaObj_GetMediaDataRefCount, 1,
|
|
"() -> (short count)"},
|
|
{"SetMediaPlayHints", (PyCFunction)MediaObj_SetMediaPlayHints, 1,
|
|
"(long flags, long flagsMask) -> None"},
|
|
{"GetMediaPlayHints", (PyCFunction)MediaObj_GetMediaPlayHints, 1,
|
|
"() -> (long flags)"},
|
|
{"GetMediaNextInterestingTimeOnly", (PyCFunction)MediaObj_GetMediaNextInterestingTimeOnly, 1,
|
|
"(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime)"},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
PyMethodChain MediaObj_chain = { MediaObj_methods, NULL };
|
|
|
|
static PyObject *MediaObj_getattr(MediaObject *self, char *name)
|
|
{
|
|
return Py_FindMethodInChain(&MediaObj_chain, (PyObject *)self, name);
|
|
}
|
|
|
|
#define MediaObj_setattr NULL
|
|
|
|
#define MediaObj_compare NULL
|
|
|
|
#define MediaObj_repr NULL
|
|
|
|
#define MediaObj_hash NULL
|
|
|
|
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) MediaObj_getattr, /*tp_getattr*/
|
|
(setattrfunc) MediaObj_setattr, /*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*/
|
|
};
|
|
|
|
/* --------------------- End object type Media ---------------------- */
|
|
|
|
|
|
/* ----------------------- Object type Track ------------------------ */
|
|
|
|
PyTypeObject Track_Type;
|
|
|
|
#define TrackObj_Check(x) ((x)->ob_type == &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 null Track");
|
|
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 (!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)
|
|
{
|
|
DisposeMovieTrack(self->ob_itself);
|
|
PyMem_DEL(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_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,
|
|
"(TimeValue time, TimeValue duration, long flags) -> None"},
|
|
{"GetTrackPict", (PyCFunction)TrackObj_GetTrackPict, 1,
|
|
"(TimeValue time) -> (PicHandle _rv)"},
|
|
{"GetTrackClipRgn", (PyCFunction)TrackObj_GetTrackClipRgn, 1,
|
|
"() -> (RgnHandle _rv)"},
|
|
{"SetTrackClipRgn", (PyCFunction)TrackObj_SetTrackClipRgn, 1,
|
|
"(RgnHandle theClip) -> None"},
|
|
{"GetTrackDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackDisplayBoundsRgn, 1,
|
|
"() -> (RgnHandle _rv)"},
|
|
{"GetTrackMovieBoundsRgn", (PyCFunction)TrackObj_GetTrackMovieBoundsRgn, 1,
|
|
"() -> (RgnHandle _rv)"},
|
|
{"GetTrackBoundsRgn", (PyCFunction)TrackObj_GetTrackBoundsRgn, 1,
|
|
"() -> (RgnHandle _rv)"},
|
|
{"GetTrackMatte", (PyCFunction)TrackObj_GetTrackMatte, 1,
|
|
"() -> (PixMapHandle _rv)"},
|
|
{"SetTrackMatte", (PyCFunction)TrackObj_SetTrackMatte, 1,
|
|
"(PixMapHandle theMatte) -> None"},
|
|
{"GetTrackID", (PyCFunction)TrackObj_GetTrackID, 1,
|
|
"() -> (long _rv)"},
|
|
{"GetTrackMovie", (PyCFunction)TrackObj_GetTrackMovie, 1,
|
|
"() -> (Movie _rv)"},
|
|
{"GetTrackCreationTime", (PyCFunction)TrackObj_GetTrackCreationTime, 1,
|
|
"() -> (unsigned long _rv)"},
|
|
{"GetTrackModificationTime", (PyCFunction)TrackObj_GetTrackModificationTime, 1,
|
|
"() -> (unsigned long _rv)"},
|
|
{"GetTrackEnabled", (PyCFunction)TrackObj_GetTrackEnabled, 1,
|
|
"() -> (Boolean _rv)"},
|
|
{"SetTrackEnabled", (PyCFunction)TrackObj_SetTrackEnabled, 1,
|
|
"(Boolean isEnabled) -> None"},
|
|
{"GetTrackUsage", (PyCFunction)TrackObj_GetTrackUsage, 1,
|
|
"() -> (long _rv)"},
|
|
{"SetTrackUsage", (PyCFunction)TrackObj_SetTrackUsage, 1,
|
|
"(long usage) -> None"},
|
|
{"GetTrackDuration", (PyCFunction)TrackObj_GetTrackDuration, 1,
|
|
"() -> (TimeValue _rv)"},
|
|
{"GetTrackOffset", (PyCFunction)TrackObj_GetTrackOffset, 1,
|
|
"() -> (TimeValue _rv)"},
|
|
{"SetTrackOffset", (PyCFunction)TrackObj_SetTrackOffset, 1,
|
|
"(TimeValue movieOffsetTime) -> None"},
|
|
{"GetTrackLayer", (PyCFunction)TrackObj_GetTrackLayer, 1,
|
|
"() -> (short _rv)"},
|
|
{"SetTrackLayer", (PyCFunction)TrackObj_SetTrackLayer, 1,
|
|
"(short layer) -> None"},
|
|
{"GetTrackAlternate", (PyCFunction)TrackObj_GetTrackAlternate, 1,
|
|
"() -> (Track _rv)"},
|
|
{"SetTrackAlternate", (PyCFunction)TrackObj_SetTrackAlternate, 1,
|
|
"(Track alternateT) -> None"},
|
|
{"GetTrackVolume", (PyCFunction)TrackObj_GetTrackVolume, 1,
|
|
"() -> (short _rv)"},
|
|
{"SetTrackVolume", (PyCFunction)TrackObj_SetTrackVolume, 1,
|
|
"(short volume) -> None"},
|
|
{"GetTrackDimensions", (PyCFunction)TrackObj_GetTrackDimensions, 1,
|
|
"() -> (Fixed width, Fixed height)"},
|
|
{"SetTrackDimensions", (PyCFunction)TrackObj_SetTrackDimensions, 1,
|
|
"(Fixed width, Fixed height) -> None"},
|
|
{"GetTrackUserData", (PyCFunction)TrackObj_GetTrackUserData, 1,
|
|
"() -> (UserData _rv)"},
|
|
{"GetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_GetTrackSoundLocalizationSettings, 1,
|
|
"() -> (Handle settings)"},
|
|
{"SetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_SetTrackSoundLocalizationSettings, 1,
|
|
"(Handle settings) -> None"},
|
|
{"NewTrackMedia", (PyCFunction)TrackObj_NewTrackMedia, 1,
|
|
"(OSType mediaType, TimeScale timeScale, Handle dataRef, OSType dataRefType) -> (Media _rv)"},
|
|
{"GetTrackMedia", (PyCFunction)TrackObj_GetTrackMedia, 1,
|
|
"() -> (Media _rv)"},
|
|
{"InsertMediaIntoTrack", (PyCFunction)TrackObj_InsertMediaIntoTrack, 1,
|
|
"(TimeValue trackStart, TimeValue mediaTime, TimeValue mediaDuration, Fixed mediaRate) -> None"},
|
|
{"InsertTrackSegment", (PyCFunction)TrackObj_InsertTrackSegment, 1,
|
|
"(Track dstTrack, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None"},
|
|
{"InsertEmptyTrackSegment", (PyCFunction)TrackObj_InsertEmptyTrackSegment, 1,
|
|
"(TimeValue dstIn, TimeValue dstDuration) -> None"},
|
|
{"DeleteTrackSegment", (PyCFunction)TrackObj_DeleteTrackSegment, 1,
|
|
"(TimeValue startTime, TimeValue duration) -> None"},
|
|
{"ScaleTrackSegment", (PyCFunction)TrackObj_ScaleTrackSegment, 1,
|
|
"(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None"},
|
|
{"IsScrapMovie", (PyCFunction)TrackObj_IsScrapMovie, 1,
|
|
"() -> (Component _rv)"},
|
|
{"CopyTrackSettings", (PyCFunction)TrackObj_CopyTrackSettings, 1,
|
|
"(Track dstTrack) -> None"},
|
|
{"AddEmptyTrackToMovie", (PyCFunction)TrackObj_AddEmptyTrackToMovie, 1,
|
|
"(Movie dstMovie, Handle dataRef, OSType dataRefType) -> (Track dstTrack)"},
|
|
{"AddClonedTrackToMovie", (PyCFunction)TrackObj_AddClonedTrackToMovie, 1,
|
|
"(Movie dstMovie, long flags) -> (Track dstTrack)"},
|
|
{"AddTrackReference", (PyCFunction)TrackObj_AddTrackReference, 1,
|
|
"(Track refTrack, OSType refType) -> (long addedIndex)"},
|
|
{"DeleteTrackReference", (PyCFunction)TrackObj_DeleteTrackReference, 1,
|
|
"(OSType refType, long index) -> None"},
|
|
{"SetTrackReference", (PyCFunction)TrackObj_SetTrackReference, 1,
|
|
"(Track refTrack, OSType refType, long index) -> None"},
|
|
{"GetTrackReference", (PyCFunction)TrackObj_GetTrackReference, 1,
|
|
"(OSType refType, long index) -> (Track _rv)"},
|
|
{"GetNextTrackReferenceType", (PyCFunction)TrackObj_GetNextTrackReferenceType, 1,
|
|
"(OSType refType) -> (OSType _rv)"},
|
|
{"GetTrackReferenceCount", (PyCFunction)TrackObj_GetTrackReferenceCount, 1,
|
|
"(OSType refType) -> (long _rv)"},
|
|
{"GetTrackEditRate", (PyCFunction)TrackObj_GetTrackEditRate, 1,
|
|
"(TimeValue atTime) -> (Fixed _rv)"},
|
|
{"GetTrackDataSize", (PyCFunction)TrackObj_GetTrackDataSize, 1,
|
|
"(TimeValue startTime, TimeValue duration) -> (long _rv)"},
|
|
{"GetTrackDataSize64", (PyCFunction)TrackObj_GetTrackDataSize64, 1,
|
|
"(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
|
|
{"PtInTrack", (PyCFunction)TrackObj_PtInTrack, 1,
|
|
"(Point pt) -> (Boolean _rv)"},
|
|
{"GetTrackNextInterestingTime", (PyCFunction)TrackObj_GetTrackNextInterestingTime, 1,
|
|
"(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
|
|
{"GetTrackSegmentDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackSegmentDisplayBoundsRgn, 1,
|
|
"(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"},
|
|
{"GetTrackStatus", (PyCFunction)TrackObj_GetTrackStatus, 1,
|
|
"() -> (ComponentResult _rv)"},
|
|
{"SetTrackLoadSettings", (PyCFunction)TrackObj_SetTrackLoadSettings, 1,
|
|
"(TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints) -> None"},
|
|
{"GetTrackLoadSettings", (PyCFunction)TrackObj_GetTrackLoadSettings, 1,
|
|
"() -> (TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints)"},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
PyMethodChain TrackObj_chain = { TrackObj_methods, NULL };
|
|
|
|
static PyObject *TrackObj_getattr(TrackObject *self, char *name)
|
|
{
|
|
return Py_FindMethodInChain(&TrackObj_chain, (PyObject *)self, name);
|
|
}
|
|
|
|
#define TrackObj_setattr NULL
|
|
|
|
#define TrackObj_compare NULL
|
|
|
|
#define TrackObj_repr NULL
|
|
|
|
#define TrackObj_hash NULL
|
|
|
|
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) TrackObj_getattr, /*tp_getattr*/
|
|
(setattrfunc) TrackObj_setattr, /*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*/
|
|
};
|
|
|
|
/* --------------------- End object type Track ---------------------- */
|
|
|
|
|
|
/* ----------------------- Object type Movie ------------------------ */
|
|
|
|
PyTypeObject Movie_Type;
|
|
|
|
#define MovieObj_Check(x) ((x)->ob_type == &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 null Movie");
|
|
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 (!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)
|
|
{
|
|
DisposeMovie(self->ob_itself);
|
|
PyMem_DEL(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_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_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_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_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;
|
|
}
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
|
|
static PyObject *MovieObj_SetMovieAnchorDataRef(MovieObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
Handle dataRef;
|
|
OSType dataRefType;
|
|
#ifndef SetMovieAnchorDataRef
|
|
PyMac_PRECHECK(SetMovieAnchorDataRef);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
ResObj_Convert, &dataRef,
|
|
PyMac_GetOSType, &dataRefType))
|
|
return NULL;
|
|
_err = SetMovieAnchorDataRef(_self->ob_itself,
|
|
dataRef,
|
|
dataRefType);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
#endif
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
|
|
static PyObject *MovieObj_GetMovieAnchorDataRef(MovieObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
Handle dataRef;
|
|
OSType dataRefType;
|
|
long outFlags;
|
|
#ifndef GetMovieAnchorDataRef
|
|
PyMac_PRECHECK(GetMovieAnchorDataRef);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = GetMovieAnchorDataRef(_self->ob_itself,
|
|
&dataRef,
|
|
&dataRefType,
|
|
&outFlags);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&O&l",
|
|
ResObj_New, dataRef,
|
|
PyMac_BuildOSType, dataRefType,
|
|
outFlags);
|
|
return _res;
|
|
}
|
|
#endif
|
|
|
|
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_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;
|
|
}
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
|
|
static PyObject *MovieObj_GetMovieLoadState(MovieObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
long _rv;
|
|
#ifndef GetMovieLoadState
|
|
PyMac_PRECHECK(GetMovieLoadState);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = GetMovieLoadState(_self->ob_itself);
|
|
_res = Py_BuildValue("l",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
#endif
|
|
|
|
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,
|
|
"(long maxMilliSecToUse) -> None"},
|
|
{"PrerollMovie", (PyCFunction)MovieObj_PrerollMovie, 1,
|
|
"(TimeValue time, Fixed Rate) -> None"},
|
|
{"AbortPrePrerollMovie", (PyCFunction)MovieObj_AbortPrePrerollMovie, 1,
|
|
"(OSErr err) -> None"},
|
|
{"LoadMovieIntoRam", (PyCFunction)MovieObj_LoadMovieIntoRam, 1,
|
|
"(TimeValue time, TimeValue duration, long flags) -> None"},
|
|
{"SetMovieActive", (PyCFunction)MovieObj_SetMovieActive, 1,
|
|
"(Boolean active) -> None"},
|
|
{"GetMovieActive", (PyCFunction)MovieObj_GetMovieActive, 1,
|
|
"() -> (Boolean _rv)"},
|
|
{"StartMovie", (PyCFunction)MovieObj_StartMovie, 1,
|
|
"() -> None"},
|
|
{"StopMovie", (PyCFunction)MovieObj_StopMovie, 1,
|
|
"() -> None"},
|
|
{"GoToBeginningOfMovie", (PyCFunction)MovieObj_GoToBeginningOfMovie, 1,
|
|
"() -> None"},
|
|
{"GoToEndOfMovie", (PyCFunction)MovieObj_GoToEndOfMovie, 1,
|
|
"() -> None"},
|
|
{"IsMovieDone", (PyCFunction)MovieObj_IsMovieDone, 1,
|
|
"() -> (Boolean _rv)"},
|
|
{"GetMoviePreviewMode", (PyCFunction)MovieObj_GetMoviePreviewMode, 1,
|
|
"() -> (Boolean _rv)"},
|
|
{"SetMoviePreviewMode", (PyCFunction)MovieObj_SetMoviePreviewMode, 1,
|
|
"(Boolean usePreview) -> None"},
|
|
{"ShowMoviePoster", (PyCFunction)MovieObj_ShowMoviePoster, 1,
|
|
"() -> None"},
|
|
{"GetMovieTimeBase", (PyCFunction)MovieObj_GetMovieTimeBase, 1,
|
|
"() -> (TimeBase _rv)"},
|
|
{"SetMovieMasterTimeBase", (PyCFunction)MovieObj_SetMovieMasterTimeBase, 1,
|
|
"(TimeBase tb, TimeRecord slaveZero) -> None"},
|
|
{"SetMovieMasterClock", (PyCFunction)MovieObj_SetMovieMasterClock, 1,
|
|
"(Component clockMeister, TimeRecord slaveZero) -> None"},
|
|
{"GetMovieGWorld", (PyCFunction)MovieObj_GetMovieGWorld, 1,
|
|
"() -> (CGrafPtr port, GDHandle gdh)"},
|
|
{"SetMovieGWorld", (PyCFunction)MovieObj_SetMovieGWorld, 1,
|
|
"(CGrafPtr port, GDHandle gdh) -> None"},
|
|
{"GetMovieNaturalBoundsRect", (PyCFunction)MovieObj_GetMovieNaturalBoundsRect, 1,
|
|
"() -> (Rect naturalBounds)"},
|
|
{"GetNextTrackForCompositing", (PyCFunction)MovieObj_GetNextTrackForCompositing, 1,
|
|
"(Track theTrack) -> (Track _rv)"},
|
|
{"GetPrevTrackForCompositing", (PyCFunction)MovieObj_GetPrevTrackForCompositing, 1,
|
|
"(Track theTrack) -> (Track _rv)"},
|
|
{"GetMoviePict", (PyCFunction)MovieObj_GetMoviePict, 1,
|
|
"(TimeValue time) -> (PicHandle _rv)"},
|
|
{"GetMoviePosterPict", (PyCFunction)MovieObj_GetMoviePosterPict, 1,
|
|
"() -> (PicHandle _rv)"},
|
|
{"UpdateMovie", (PyCFunction)MovieObj_UpdateMovie, 1,
|
|
"() -> None"},
|
|
{"InvalidateMovieRegion", (PyCFunction)MovieObj_InvalidateMovieRegion, 1,
|
|
"(RgnHandle invalidRgn) -> None"},
|
|
{"GetMovieBox", (PyCFunction)MovieObj_GetMovieBox, 1,
|
|
"() -> (Rect boxRect)"},
|
|
{"SetMovieBox", (PyCFunction)MovieObj_SetMovieBox, 1,
|
|
"(Rect boxRect) -> None"},
|
|
{"GetMovieDisplayClipRgn", (PyCFunction)MovieObj_GetMovieDisplayClipRgn, 1,
|
|
"() -> (RgnHandle _rv)"},
|
|
{"SetMovieDisplayClipRgn", (PyCFunction)MovieObj_SetMovieDisplayClipRgn, 1,
|
|
"(RgnHandle theClip) -> None"},
|
|
{"GetMovieClipRgn", (PyCFunction)MovieObj_GetMovieClipRgn, 1,
|
|
"() -> (RgnHandle _rv)"},
|
|
{"SetMovieClipRgn", (PyCFunction)MovieObj_SetMovieClipRgn, 1,
|
|
"(RgnHandle theClip) -> None"},
|
|
{"GetMovieDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieDisplayBoundsRgn, 1,
|
|
"() -> (RgnHandle _rv)"},
|
|
{"GetMovieBoundsRgn", (PyCFunction)MovieObj_GetMovieBoundsRgn, 1,
|
|
"() -> (RgnHandle _rv)"},
|
|
{"SetMovieVideoOutput", (PyCFunction)MovieObj_SetMovieVideoOutput, 1,
|
|
"(ComponentInstance vout) -> None"},
|
|
{"PutMovieIntoHandle", (PyCFunction)MovieObj_PutMovieIntoHandle, 1,
|
|
"(Handle publicMovie) -> None"},
|
|
{"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1,
|
|
"(short fRefNum, long offset, long maxSize) -> None"},
|
|
{"PutMovieIntoDataFork64", (PyCFunction)MovieObj_PutMovieIntoDataFork64, 1,
|
|
"(long fRefNum, wide offset, unsigned long maxSize) -> None"},
|
|
{"GetMovieCreationTime", (PyCFunction)MovieObj_GetMovieCreationTime, 1,
|
|
"() -> (unsigned long _rv)"},
|
|
{"GetMovieModificationTime", (PyCFunction)MovieObj_GetMovieModificationTime, 1,
|
|
"() -> (unsigned long _rv)"},
|
|
{"GetMovieTimeScale", (PyCFunction)MovieObj_GetMovieTimeScale, 1,
|
|
"() -> (TimeScale _rv)"},
|
|
{"SetMovieTimeScale", (PyCFunction)MovieObj_SetMovieTimeScale, 1,
|
|
"(TimeScale timeScale) -> None"},
|
|
{"GetMovieDuration", (PyCFunction)MovieObj_GetMovieDuration, 1,
|
|
"() -> (TimeValue _rv)"},
|
|
{"GetMovieRate", (PyCFunction)MovieObj_GetMovieRate, 1,
|
|
"() -> (Fixed _rv)"},
|
|
{"SetMovieRate", (PyCFunction)MovieObj_SetMovieRate, 1,
|
|
"(Fixed rate) -> None"},
|
|
{"GetMoviePreferredRate", (PyCFunction)MovieObj_GetMoviePreferredRate, 1,
|
|
"() -> (Fixed _rv)"},
|
|
{"SetMoviePreferredRate", (PyCFunction)MovieObj_SetMoviePreferredRate, 1,
|
|
"(Fixed rate) -> None"},
|
|
{"GetMoviePreferredVolume", (PyCFunction)MovieObj_GetMoviePreferredVolume, 1,
|
|
"() -> (short _rv)"},
|
|
{"SetMoviePreferredVolume", (PyCFunction)MovieObj_SetMoviePreferredVolume, 1,
|
|
"(short volume) -> None"},
|
|
{"GetMovieVolume", (PyCFunction)MovieObj_GetMovieVolume, 1,
|
|
"() -> (short _rv)"},
|
|
{"SetMovieVolume", (PyCFunction)MovieObj_SetMovieVolume, 1,
|
|
"(short volume) -> None"},
|
|
{"GetMoviePreviewTime", (PyCFunction)MovieObj_GetMoviePreviewTime, 1,
|
|
"() -> (TimeValue previewTime, TimeValue previewDuration)"},
|
|
{"SetMoviePreviewTime", (PyCFunction)MovieObj_SetMoviePreviewTime, 1,
|
|
"(TimeValue previewTime, TimeValue previewDuration) -> None"},
|
|
{"GetMoviePosterTime", (PyCFunction)MovieObj_GetMoviePosterTime, 1,
|
|
"() -> (TimeValue _rv)"},
|
|
{"SetMoviePosterTime", (PyCFunction)MovieObj_SetMoviePosterTime, 1,
|
|
"(TimeValue posterTime) -> None"},
|
|
{"GetMovieSelection", (PyCFunction)MovieObj_GetMovieSelection, 1,
|
|
"() -> (TimeValue selectionTime, TimeValue selectionDuration)"},
|
|
{"SetMovieSelection", (PyCFunction)MovieObj_SetMovieSelection, 1,
|
|
"(TimeValue selectionTime, TimeValue selectionDuration) -> None"},
|
|
{"SetMovieActiveSegment", (PyCFunction)MovieObj_SetMovieActiveSegment, 1,
|
|
"(TimeValue startTime, TimeValue duration) -> None"},
|
|
{"GetMovieActiveSegment", (PyCFunction)MovieObj_GetMovieActiveSegment, 1,
|
|
"() -> (TimeValue startTime, TimeValue duration)"},
|
|
{"GetMovieTime", (PyCFunction)MovieObj_GetMovieTime, 1,
|
|
"() -> (TimeValue _rv, TimeRecord currentTime)"},
|
|
{"SetMovieTime", (PyCFunction)MovieObj_SetMovieTime, 1,
|
|
"(TimeRecord newtime) -> None"},
|
|
{"SetMovieTimeValue", (PyCFunction)MovieObj_SetMovieTimeValue, 1,
|
|
"(TimeValue newtime) -> None"},
|
|
{"GetMovieUserData", (PyCFunction)MovieObj_GetMovieUserData, 1,
|
|
"() -> (UserData _rv)"},
|
|
{"GetMovieTrackCount", (PyCFunction)MovieObj_GetMovieTrackCount, 1,
|
|
"() -> (long _rv)"},
|
|
{"GetMovieTrack", (PyCFunction)MovieObj_GetMovieTrack, 1,
|
|
"(long trackID) -> (Track _rv)"},
|
|
{"GetMovieIndTrack", (PyCFunction)MovieObj_GetMovieIndTrack, 1,
|
|
"(long index) -> (Track _rv)"},
|
|
{"GetMovieIndTrackType", (PyCFunction)MovieObj_GetMovieIndTrackType, 1,
|
|
"(long index, OSType trackType, long flags) -> (Track _rv)"},
|
|
{"NewMovieTrack", (PyCFunction)MovieObj_NewMovieTrack, 1,
|
|
"(Fixed width, Fixed height, short trackVolume) -> (Track _rv)"},
|
|
{"SetAutoTrackAlternatesEnabled", (PyCFunction)MovieObj_SetAutoTrackAlternatesEnabled, 1,
|
|
"(Boolean enable) -> None"},
|
|
{"SelectMovieAlternates", (PyCFunction)MovieObj_SelectMovieAlternates, 1,
|
|
"() -> None"},
|
|
{"InsertMovieSegment", (PyCFunction)MovieObj_InsertMovieSegment, 1,
|
|
"(Movie dstMovie, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None"},
|
|
{"InsertEmptyMovieSegment", (PyCFunction)MovieObj_InsertEmptyMovieSegment, 1,
|
|
"(TimeValue dstIn, TimeValue dstDuration) -> None"},
|
|
{"DeleteMovieSegment", (PyCFunction)MovieObj_DeleteMovieSegment, 1,
|
|
"(TimeValue startTime, TimeValue duration) -> None"},
|
|
{"ScaleMovieSegment", (PyCFunction)MovieObj_ScaleMovieSegment, 1,
|
|
"(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None"},
|
|
{"CutMovieSelection", (PyCFunction)MovieObj_CutMovieSelection, 1,
|
|
"() -> (Movie _rv)"},
|
|
{"CopyMovieSelection", (PyCFunction)MovieObj_CopyMovieSelection, 1,
|
|
"() -> (Movie _rv)"},
|
|
{"PasteMovieSelection", (PyCFunction)MovieObj_PasteMovieSelection, 1,
|
|
"(Movie src) -> None"},
|
|
{"AddMovieSelection", (PyCFunction)MovieObj_AddMovieSelection, 1,
|
|
"(Movie src) -> None"},
|
|
{"ClearMovieSelection", (PyCFunction)MovieObj_ClearMovieSelection, 1,
|
|
"() -> None"},
|
|
{"PutMovieIntoTypedHandle", (PyCFunction)MovieObj_PutMovieIntoTypedHandle, 1,
|
|
"(Track targetTrack, OSType handleType, Handle publicMovie, TimeValue start, TimeValue dur, long flags, ComponentInstance userComp) -> None"},
|
|
{"CopyMovieSettings", (PyCFunction)MovieObj_CopyMovieSettings, 1,
|
|
"(Movie dstMovie) -> None"},
|
|
{"ConvertMovieToFile", (PyCFunction)MovieObj_ConvertMovieToFile, 1,
|
|
"(Track onlyTrack, FSSpec outputFile, OSType fileType, OSType creator, ScriptCode scriptTag, long flags, ComponentInstance userComp) -> (short resID)"},
|
|
{"GetMovieDataSize", (PyCFunction)MovieObj_GetMovieDataSize, 1,
|
|
"(TimeValue startTime, TimeValue duration) -> (long _rv)"},
|
|
{"GetMovieDataSize64", (PyCFunction)MovieObj_GetMovieDataSize64, 1,
|
|
"(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
|
|
{"PtInMovie", (PyCFunction)MovieObj_PtInMovie, 1,
|
|
"(Point pt) -> (Boolean _rv)"},
|
|
{"SetMovieLanguage", (PyCFunction)MovieObj_SetMovieLanguage, 1,
|
|
"(long language) -> None"},
|
|
{"GetMovieNextInterestingTime", (PyCFunction)MovieObj_GetMovieNextInterestingTime, 1,
|
|
"(short interestingTimeFlags, short numMediaTypes, OSType whichMediaTypes, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
|
|
{"AddMovieResource", (PyCFunction)MovieObj_AddMovieResource, 1,
|
|
"(short resRefNum, Str255 resName) -> (short resId)"},
|
|
{"UpdateMovieResource", (PyCFunction)MovieObj_UpdateMovieResource, 1,
|
|
"(short resRefNum, short resId, Str255 resName) -> None"},
|
|
{"HasMovieChanged", (PyCFunction)MovieObj_HasMovieChanged, 1,
|
|
"() -> (Boolean _rv)"},
|
|
{"ClearMovieChanged", (PyCFunction)MovieObj_ClearMovieChanged, 1,
|
|
"() -> None"},
|
|
{"SetMovieDefaultDataRef", (PyCFunction)MovieObj_SetMovieDefaultDataRef, 1,
|
|
"(Handle dataRef, OSType dataRefType) -> None"},
|
|
{"GetMovieDefaultDataRef", (PyCFunction)MovieObj_GetMovieDefaultDataRef, 1,
|
|
"() -> (Handle dataRef, OSType dataRefType)"},
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
{"SetMovieAnchorDataRef", (PyCFunction)MovieObj_SetMovieAnchorDataRef, 1,
|
|
"(Handle dataRef, OSType dataRefType) -> None"},
|
|
#endif
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
{"GetMovieAnchorDataRef", (PyCFunction)MovieObj_GetMovieAnchorDataRef, 1,
|
|
"() -> (Handle dataRef, OSType dataRefType, long outFlags)"},
|
|
#endif
|
|
{"SetMovieColorTable", (PyCFunction)MovieObj_SetMovieColorTable, 1,
|
|
"(CTabHandle ctab) -> None"},
|
|
{"GetMovieColorTable", (PyCFunction)MovieObj_GetMovieColorTable, 1,
|
|
"() -> (CTabHandle ctab)"},
|
|
{"FlattenMovie", (PyCFunction)MovieObj_FlattenMovie, 1,
|
|
"(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Str255 resName) -> (short resId)"},
|
|
{"FlattenMovieData", (PyCFunction)MovieObj_FlattenMovieData, 1,
|
|
"(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)"},
|
|
{"MovieSearchText", (PyCFunction)MovieObj_MovieSearchText, 1,
|
|
"(Ptr text, long size, long searchFlags) -> (Track searchTrack, TimeValue searchTime, long searchOffset)"},
|
|
{"GetPosterBox", (PyCFunction)MovieObj_GetPosterBox, 1,
|
|
"() -> (Rect boxRect)"},
|
|
{"SetPosterBox", (PyCFunction)MovieObj_SetPosterBox, 1,
|
|
"(Rect boxRect) -> None"},
|
|
{"GetMovieSegmentDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieSegmentDisplayBoundsRgn, 1,
|
|
"(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"},
|
|
{"GetMovieStatus", (PyCFunction)MovieObj_GetMovieStatus, 1,
|
|
"() -> (ComponentResult _rv, Track firstProblemTrack)"},
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
{"GetMovieLoadState", (PyCFunction)MovieObj_GetMovieLoadState, 1,
|
|
"() -> (long _rv)"},
|
|
#endif
|
|
{"NewMovieController", (PyCFunction)MovieObj_NewMovieController, 1,
|
|
"(Rect movieRect, long someFlags) -> (MovieController _rv)"},
|
|
{"PutMovieOnScrap", (PyCFunction)MovieObj_PutMovieOnScrap, 1,
|
|
"(long movieScrapFlags) -> None"},
|
|
{"SetMoviePlayHints", (PyCFunction)MovieObj_SetMoviePlayHints, 1,
|
|
"(long flags, long flagsMask) -> None"},
|
|
{"GetMaxLoadedTimeInMovie", (PyCFunction)MovieObj_GetMaxLoadedTimeInMovie, 1,
|
|
"() -> (TimeValue time)"},
|
|
{"QTMovieNeedsTimeTable", (PyCFunction)MovieObj_QTMovieNeedsTimeTable, 1,
|
|
"() -> (Boolean needsTimeTable)"},
|
|
{"QTGetDataRefMaxFileOffset", (PyCFunction)MovieObj_QTGetDataRefMaxFileOffset, 1,
|
|
"(OSType dataRefType, Handle dataRef) -> (long offset)"},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
PyMethodChain MovieObj_chain = { MovieObj_methods, NULL };
|
|
|
|
static PyObject *MovieObj_getattr(MovieObject *self, char *name)
|
|
{
|
|
return Py_FindMethodInChain(&MovieObj_chain, (PyObject *)self, name);
|
|
}
|
|
|
|
#define MovieObj_setattr NULL
|
|
|
|
#define MovieObj_compare NULL
|
|
|
|
#define MovieObj_repr NULL
|
|
|
|
#define MovieObj_hash NULL
|
|
|
|
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) MovieObj_getattr, /*tp_getattr*/
|
|
(setattrfunc) MovieObj_setattr, /*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*/
|
|
};
|
|
|
|
/* --------------------- End object type Movie ---------------------- */
|
|
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
|
|
static PyObject *Qt_CheckQuickTimeRegistration(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
void * registrationKey;
|
|
long flags;
|
|
#ifndef CheckQuickTimeRegistration
|
|
PyMac_PRECHECK(CheckQuickTimeRegistration);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "sl",
|
|
®istrationKey,
|
|
&flags))
|
|
return NULL;
|
|
CheckQuickTimeRegistration(registrationKey,
|
|
flags);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
#endif
|
|
|
|
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_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_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;
|
|
}
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
|
|
static PyObject *Qt_OpenADataHandler(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
Handle dataRef;
|
|
OSType dataHandlerSubType;
|
|
Handle anchorDataRef;
|
|
OSType anchorDataRefType;
|
|
TimeBase tb;
|
|
long flags;
|
|
ComponentInstance dh;
|
|
#ifndef OpenADataHandler
|
|
PyMac_PRECHECK(OpenADataHandler);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&O&O&O&l",
|
|
ResObj_Convert, &dataRef,
|
|
PyMac_GetOSType, &dataHandlerSubType,
|
|
ResObj_Convert, &anchorDataRef,
|
|
PyMac_GetOSType, &anchorDataRefType,
|
|
TimeBaseObj_Convert, &tb,
|
|
&flags))
|
|
return NULL;
|
|
_err = OpenADataHandler(dataRef,
|
|
dataHandlerSubType,
|
|
anchorDataRef,
|
|
anchorDataRefType,
|
|
tb,
|
|
flags,
|
|
&dh);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
CmpInstObj_New, dh);
|
|
return _res;
|
|
}
|
|
#endif
|
|
|
|
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 dataRefType;
|
|
#ifndef NewMovieFromDataRef
|
|
PyMac_PRECHECK(NewMovieFromDataRef);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "hO&O&",
|
|
&flags,
|
|
ResObj_Convert, &dataRef,
|
|
PyMac_GetOSType, &dataRefType))
|
|
return NULL;
|
|
_err = NewMovieFromDataRef(&m,
|
|
flags,
|
|
&id,
|
|
dataRef,
|
|
dataRefType);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&h",
|
|
MovieObj_New, m,
|
|
id);
|
|
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_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_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;
|
|
}
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
|
|
static PyObject *Qt_SpriteMediaGetIndImageProperty(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
ComponentResult _rv;
|
|
MediaHandler mh;
|
|
short imageIndex;
|
|
long imagePropertyType;
|
|
void * imagePropertyValue;
|
|
#ifndef SpriteMediaGetIndImageProperty
|
|
PyMac_PRECHECK(SpriteMediaGetIndImageProperty);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&hls",
|
|
CmpInstObj_Convert, &mh,
|
|
&imageIndex,
|
|
&imagePropertyType,
|
|
&imagePropertyValue))
|
|
return NULL;
|
|
_rv = SpriteMediaGetIndImageProperty(mh,
|
|
imageIndex,
|
|
imagePropertyType,
|
|
imagePropertyValue);
|
|
_res = Py_BuildValue("l",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
#endif
|
|
|
|
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_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;
|
|
}
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
|
|
static PyObject *Qt_MovieMediaGetCurrentMovieProperty(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
ComponentResult _rv;
|
|
MediaHandler mh;
|
|
OSType whichProperty;
|
|
void * value;
|
|
#ifndef MovieMediaGetCurrentMovieProperty
|
|
PyMac_PRECHECK(MovieMediaGetCurrentMovieProperty);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&s",
|
|
CmpInstObj_Convert, &mh,
|
|
PyMac_GetOSType, &whichProperty,
|
|
&value))
|
|
return NULL;
|
|
_rv = MovieMediaGetCurrentMovieProperty(mh,
|
|
whichProperty,
|
|
value);
|
|
_res = Py_BuildValue("l",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
#endif
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
|
|
static PyObject *Qt_MovieMediaGetCurrentTrackProperty(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
ComponentResult _rv;
|
|
MediaHandler mh;
|
|
long trackID;
|
|
OSType whichProperty;
|
|
void * value;
|
|
#ifndef MovieMediaGetCurrentTrackProperty
|
|
PyMac_PRECHECK(MovieMediaGetCurrentTrackProperty);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&lO&s",
|
|
CmpInstObj_Convert, &mh,
|
|
&trackID,
|
|
PyMac_GetOSType, &whichProperty,
|
|
&value))
|
|
return NULL;
|
|
_rv = MovieMediaGetCurrentTrackProperty(mh,
|
|
trackID,
|
|
whichProperty,
|
|
value);
|
|
_res = Py_BuildValue("l",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
#endif
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
|
|
static PyObject *Qt_MovieMediaGetChildMovieDataReference(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
ComponentResult _rv;
|
|
MediaHandler mh;
|
|
QTAtomID dataRefID;
|
|
short dataRefIndex;
|
|
OSType dataRefType;
|
|
Handle dataRef;
|
|
QTAtomID dataRefIDOut;
|
|
short dataRefIndexOut;
|
|
#ifndef MovieMediaGetChildMovieDataReference
|
|
PyMac_PRECHECK(MovieMediaGetChildMovieDataReference);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&lh",
|
|
CmpInstObj_Convert, &mh,
|
|
&dataRefID,
|
|
&dataRefIndex))
|
|
return NULL;
|
|
_rv = MovieMediaGetChildMovieDataReference(mh,
|
|
dataRefID,
|
|
dataRefIndex,
|
|
&dataRefType,
|
|
&dataRef,
|
|
&dataRefIDOut,
|
|
&dataRefIndexOut);
|
|
_res = Py_BuildValue("lO&O&lh",
|
|
_rv,
|
|
PyMac_BuildOSType, dataRefType,
|
|
ResObj_New, dataRef,
|
|
dataRefIDOut,
|
|
dataRefIndexOut);
|
|
return _res;
|
|
}
|
|
#endif
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
|
|
static PyObject *Qt_MovieMediaSetChildMovieDataReference(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
ComponentResult _rv;
|
|
MediaHandler mh;
|
|
QTAtomID dataRefID;
|
|
OSType dataRefType;
|
|
Handle dataRef;
|
|
#ifndef MovieMediaSetChildMovieDataReference
|
|
PyMac_PRECHECK(MovieMediaSetChildMovieDataReference);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&lO&O&",
|
|
CmpInstObj_Convert, &mh,
|
|
&dataRefID,
|
|
PyMac_GetOSType, &dataRefType,
|
|
ResObj_Convert, &dataRef))
|
|
return NULL;
|
|
_rv = MovieMediaSetChildMovieDataReference(mh,
|
|
dataRefID,
|
|
dataRefType,
|
|
dataRef);
|
|
_res = Py_BuildValue("l",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
#endif
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
|
|
static PyObject *Qt_MovieMediaLoadChildMovieFromDataReference(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
ComponentResult _rv;
|
|
MediaHandler mh;
|
|
QTAtomID dataRefID;
|
|
#ifndef MovieMediaLoadChildMovieFromDataReference
|
|
PyMac_PRECHECK(MovieMediaLoadChildMovieFromDataReference);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&l",
|
|
CmpInstObj_Convert, &mh,
|
|
&dataRefID))
|
|
return NULL;
|
|
_rv = MovieMediaLoadChildMovieFromDataReference(mh,
|
|
dataRefID);
|
|
_res = Py_BuildValue("l",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
#endif
|
|
|
|
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;
|
|
}
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
|
|
static PyObject *Qt_Media3DGetViewObject(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
ComponentResult _rv;
|
|
MediaHandler mh;
|
|
void * tq3viewObject;
|
|
#ifndef Media3DGetViewObject
|
|
PyMac_PRECHECK(Media3DGetViewObject);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&s",
|
|
CmpInstObj_Convert, &mh,
|
|
&tq3viewObject))
|
|
return NULL;
|
|
_rv = Media3DGetViewObject(mh,
|
|
tq3viewObject);
|
|
_res = Py_BuildValue("l",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
#endif
|
|
|
|
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&",
|
|
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, "l",
|
|
&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_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;
|
|
}
|
|
|
|
static PyMethodDef Qt_methods[] = {
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
{"CheckQuickTimeRegistration", (PyCFunction)Qt_CheckQuickTimeRegistration, 1,
|
|
"(void * registrationKey, long flags) -> None"},
|
|
#endif
|
|
{"EnterMovies", (PyCFunction)Qt_EnterMovies, 1,
|
|
"() -> None"},
|
|
{"ExitMovies", (PyCFunction)Qt_ExitMovies, 1,
|
|
"() -> None"},
|
|
{"GetMoviesError", (PyCFunction)Qt_GetMoviesError, 1,
|
|
"() -> None"},
|
|
{"ClearMoviesStickyError", (PyCFunction)Qt_ClearMoviesStickyError, 1,
|
|
"() -> None"},
|
|
{"GetMoviesStickyError", (PyCFunction)Qt_GetMoviesStickyError, 1,
|
|
"() -> None"},
|
|
{"DisposeMatte", (PyCFunction)Qt_DisposeMatte, 1,
|
|
"(PixMapHandle theMatte) -> None"},
|
|
{"NewMovie", (PyCFunction)Qt_NewMovie, 1,
|
|
"(long flags) -> (Movie _rv)"},
|
|
{"GetDataHandler", (PyCFunction)Qt_GetDataHandler, 1,
|
|
"(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)"},
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
{"OpenADataHandler", (PyCFunction)Qt_OpenADataHandler, 1,
|
|
"(Handle dataRef, OSType dataHandlerSubType, Handle anchorDataRef, OSType anchorDataRefType, TimeBase tb, long flags) -> (ComponentInstance dh)"},
|
|
#endif
|
|
{"PasteHandleIntoMovie", (PyCFunction)Qt_PasteHandleIntoMovie, 1,
|
|
"(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None"},
|
|
{"GetMovieImporterForDataRef", (PyCFunction)Qt_GetMovieImporterForDataRef, 1,
|
|
"(OSType dataRefType, Handle dataRef, long flags) -> (Component importer)"},
|
|
{"QTGetMIMETypeInfo", (PyCFunction)Qt_QTGetMIMETypeInfo, 1,
|
|
"(char* mimeStringStart, short mimeStringLength, OSType infoSelector, void * infoDataPtr) -> (long infoDataSize)"},
|
|
{"TrackTimeToMediaTime", (PyCFunction)Qt_TrackTimeToMediaTime, 1,
|
|
"(TimeValue value, Track theTrack) -> (TimeValue _rv)"},
|
|
{"NewUserData", (PyCFunction)Qt_NewUserData, 1,
|
|
"() -> (UserData theUserData)"},
|
|
{"NewUserDataFromHandle", (PyCFunction)Qt_NewUserDataFromHandle, 1,
|
|
"(Handle h) -> (UserData theUserData)"},
|
|
{"CreateMovieFile", (PyCFunction)Qt_CreateMovieFile, 1,
|
|
"(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (short resRefNum, Movie newmovie)"},
|
|
{"OpenMovieFile", (PyCFunction)Qt_OpenMovieFile, 1,
|
|
"(FSSpec fileSpec, SInt8 permission) -> (short resRefNum)"},
|
|
{"CloseMovieFile", (PyCFunction)Qt_CloseMovieFile, 1,
|
|
"(short resRefNum) -> None"},
|
|
{"DeleteMovieFile", (PyCFunction)Qt_DeleteMovieFile, 1,
|
|
"(FSSpec fileSpec) -> None"},
|
|
{"NewMovieFromFile", (PyCFunction)Qt_NewMovieFromFile, 1,
|
|
"(short resRefNum, short resId, short newMovieFlags) -> (Movie theMovie, short resId, Boolean dataRefWasChanged)"},
|
|
{"NewMovieFromHandle", (PyCFunction)Qt_NewMovieFromHandle, 1,
|
|
"(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
|
|
{"NewMovieFromDataFork", (PyCFunction)Qt_NewMovieFromDataFork, 1,
|
|
"(short fRefNum, long fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
|
|
{"NewMovieFromDataFork64", (PyCFunction)Qt_NewMovieFromDataFork64, 1,
|
|
"(long fRefNum, wide fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
|
|
{"NewMovieFromDataRef", (PyCFunction)Qt_NewMovieFromDataRef, 1,
|
|
"(short flags, Handle dataRef, OSType dataRefType) -> (Movie m, short id)"},
|
|
{"RemoveMovieResource", (PyCFunction)Qt_RemoveMovieResource, 1,
|
|
"(short resRefNum, short resId) -> None"},
|
|
{"CreateShortcutMovieFile", (PyCFunction)Qt_CreateShortcutMovieFile, 1,
|
|
"(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Handle targetDataRef, OSType targetDataRefType) -> None"},
|
|
{"CanQuickTimeOpenFile", (PyCFunction)Qt_CanQuickTimeOpenFile, 1,
|
|
"(FSSpec fileSpec, OSType fileType, OSType fileNameExtension, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)"},
|
|
{"CanQuickTimeOpenDataRef", (PyCFunction)Qt_CanQuickTimeOpenDataRef, 1,
|
|
"(Handle dataRef, OSType dataRefType, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)"},
|
|
{"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1,
|
|
"(long newMovieFlags) -> (Movie _rv)"},
|
|
{"QTNewAlias", (PyCFunction)Qt_QTNewAlias, 1,
|
|
"(FSSpec fss, Boolean minimal) -> (AliasHandle alias)"},
|
|
{"EndFullScreen", (PyCFunction)Qt_EndFullScreen, 1,
|
|
"(Ptr fullState, long flags) -> None"},
|
|
{"AddSoundDescriptionExtension", (PyCFunction)Qt_AddSoundDescriptionExtension, 1,
|
|
"(SoundDescriptionHandle desc, Handle extension, OSType idType) -> None"},
|
|
{"GetSoundDescriptionExtension", (PyCFunction)Qt_GetSoundDescriptionExtension, 1,
|
|
"(SoundDescriptionHandle desc, OSType idType) -> (Handle extension)"},
|
|
{"RemoveSoundDescriptionExtension", (PyCFunction)Qt_RemoveSoundDescriptionExtension, 1,
|
|
"(SoundDescriptionHandle desc, OSType idType) -> None"},
|
|
{"QTIsStandardParameterDialogEvent", (PyCFunction)Qt_QTIsStandardParameterDialogEvent, 1,
|
|
"(QTParameterDialog createdDialog) -> (EventRecord pEvent)"},
|
|
{"QTDismissStandardParameterDialog", (PyCFunction)Qt_QTDismissStandardParameterDialog, 1,
|
|
"(QTParameterDialog createdDialog) -> None"},
|
|
{"QTStandardParameterDialogDoAction", (PyCFunction)Qt_QTStandardParameterDialogDoAction, 1,
|
|
"(QTParameterDialog createdDialog, long action, void * params) -> None"},
|
|
{"QTRegisterAccessKey", (PyCFunction)Qt_QTRegisterAccessKey, 1,
|
|
"(Str255 accessKeyType, long flags, Handle accessKey) -> None"},
|
|
{"QTUnregisterAccessKey", (PyCFunction)Qt_QTUnregisterAccessKey, 1,
|
|
"(Str255 accessKeyType, long flags, Handle accessKey) -> None"},
|
|
{"QTTextToNativeText", (PyCFunction)Qt_QTTextToNativeText, 1,
|
|
"(Handle theText, long encoding, long flags) -> None"},
|
|
{"VideoMediaResetStatistics", (PyCFunction)Qt_VideoMediaResetStatistics, 1,
|
|
"(MediaHandler mh) -> (ComponentResult _rv)"},
|
|
{"VideoMediaGetStatistics", (PyCFunction)Qt_VideoMediaGetStatistics, 1,
|
|
"(MediaHandler mh) -> (ComponentResult _rv)"},
|
|
{"VideoMediaGetStallCount", (PyCFunction)Qt_VideoMediaGetStallCount, 1,
|
|
"(MediaHandler mh) -> (ComponentResult _rv, unsigned long stalls)"},
|
|
{"VideoMediaSetCodecParameter", (PyCFunction)Qt_VideoMediaSetCodecParameter, 1,
|
|
"(MediaHandler mh, CodecType cType, OSType parameterID, long parameterChangeSeed, void * dataPtr, long dataSize) -> (ComponentResult _rv)"},
|
|
{"VideoMediaGetCodecParameter", (PyCFunction)Qt_VideoMediaGetCodecParameter, 1,
|
|
"(MediaHandler mh, CodecType cType, OSType parameterID, Handle outParameterData) -> (ComponentResult _rv)"},
|
|
{"TextMediaAddTextSample", (PyCFunction)Qt_TextMediaAddTextSample, 1,
|
|
"(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,
|
|
"(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,
|
|
"(MediaHandler mh, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor rgbHiliteColor, TimeValue sampleTime)"},
|
|
{"TextMediaDrawRaw", (PyCFunction)Qt_TextMediaDrawRaw, 1,
|
|
"(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh) -> (ComponentResult _rv)"},
|
|
{"TextMediaSetTextProperty", (PyCFunction)Qt_TextMediaSetTextProperty, 1,
|
|
"(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)"},
|
|
{"TextMediaRawSetup", (PyCFunction)Qt_TextMediaRawSetup, 1,
|
|
"(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh, TimeValue sampleDuration) -> (ComponentResult _rv)"},
|
|
{"TextMediaRawIdle", (PyCFunction)Qt_TextMediaRawIdle, 1,
|
|
"(MediaHandler mh, GWorldPtr gw, GDHandle gd, TimeValue sampleTime, long flagsIn) -> (ComponentResult _rv, long flagsOut)"},
|
|
{"TextMediaGetTextProperty", (PyCFunction)Qt_TextMediaGetTextProperty, 1,
|
|
"(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)"},
|
|
{"TextMediaFindNextText", (PyCFunction)Qt_TextMediaFindNextText, 1,
|
|
"(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)"},
|
|
{"TextMediaHiliteTextSample", (PyCFunction)Qt_TextMediaHiliteTextSample, 1,
|
|
"(MediaHandler mh, TimeValue sampleTime, short hiliteStart, short hiliteEnd) -> (ComponentResult _rv, RGBColor rgbHiliteColor)"},
|
|
{"TextMediaSetTextSampleData", (PyCFunction)Qt_TextMediaSetTextSampleData, 1,
|
|
"(MediaHandler mh, void * data, OSType dataType) -> (ComponentResult _rv)"},
|
|
{"SpriteMediaSetProperty", (PyCFunction)Qt_SpriteMediaSetProperty, 1,
|
|
"(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
|
|
{"SpriteMediaGetProperty", (PyCFunction)Qt_SpriteMediaGetProperty, 1,
|
|
"(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
|
|
{"SpriteMediaHitTestSprites", (PyCFunction)Qt_SpriteMediaHitTestSprites, 1,
|
|
"(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, short spriteHitIndex)"},
|
|
{"SpriteMediaCountSprites", (PyCFunction)Qt_SpriteMediaCountSprites, 1,
|
|
"(MediaHandler mh) -> (ComponentResult _rv, short numSprites)"},
|
|
{"SpriteMediaCountImages", (PyCFunction)Qt_SpriteMediaCountImages, 1,
|
|
"(MediaHandler mh) -> (ComponentResult _rv, short numImages)"},
|
|
{"SpriteMediaGetIndImageDescription", (PyCFunction)Qt_SpriteMediaGetIndImageDescription, 1,
|
|
"(MediaHandler mh, short imageIndex, ImageDescriptionHandle imageDescription) -> (ComponentResult _rv)"},
|
|
{"SpriteMediaGetDisplayedSampleNumber", (PyCFunction)Qt_SpriteMediaGetDisplayedSampleNumber, 1,
|
|
"(MediaHandler mh) -> (ComponentResult _rv, long sampleNum)"},
|
|
{"SpriteMediaGetSpriteName", (PyCFunction)Qt_SpriteMediaGetSpriteName, 1,
|
|
"(MediaHandler mh, QTAtomID spriteID, Str255 spriteName) -> (ComponentResult _rv)"},
|
|
{"SpriteMediaGetImageName", (PyCFunction)Qt_SpriteMediaGetImageName, 1,
|
|
"(MediaHandler mh, short imageIndex, Str255 imageName) -> (ComponentResult _rv)"},
|
|
{"SpriteMediaSetSpriteProperty", (PyCFunction)Qt_SpriteMediaSetSpriteProperty, 1,
|
|
"(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
|
|
{"SpriteMediaGetSpriteProperty", (PyCFunction)Qt_SpriteMediaGetSpriteProperty, 1,
|
|
"(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
|
|
{"SpriteMediaHitTestAllSprites", (PyCFunction)Qt_SpriteMediaHitTestAllSprites, 1,
|
|
"(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, QTAtomID spriteHitID)"},
|
|
{"SpriteMediaHitTestOneSprite", (PyCFunction)Qt_SpriteMediaHitTestOneSprite, 1,
|
|
"(MediaHandler mh, QTAtomID spriteID, long flags, Point loc) -> (ComponentResult _rv, Boolean wasHit)"},
|
|
{"SpriteMediaSpriteIndexToID", (PyCFunction)Qt_SpriteMediaSpriteIndexToID, 1,
|
|
"(MediaHandler mh, short spriteIndex) -> (ComponentResult _rv, QTAtomID spriteID)"},
|
|
{"SpriteMediaSpriteIDToIndex", (PyCFunction)Qt_SpriteMediaSpriteIDToIndex, 1,
|
|
"(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv, short spriteIndex)"},
|
|
{"SpriteMediaSetActionVariable", (PyCFunction)Qt_SpriteMediaSetActionVariable, 1,
|
|
"(MediaHandler mh, QTAtomID variableID, float value) -> (ComponentResult _rv)"},
|
|
{"SpriteMediaGetActionVariable", (PyCFunction)Qt_SpriteMediaGetActionVariable, 1,
|
|
"(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, float value)"},
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
{"SpriteMediaGetIndImageProperty", (PyCFunction)Qt_SpriteMediaGetIndImageProperty, 1,
|
|
"(MediaHandler mh, short imageIndex, long imagePropertyType, void * imagePropertyValue) -> (ComponentResult _rv)"},
|
|
#endif
|
|
{"SpriteMediaDisposeSprite", (PyCFunction)Qt_SpriteMediaDisposeSprite, 1,
|
|
"(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv)"},
|
|
{"SpriteMediaSetActionVariableToString", (PyCFunction)Qt_SpriteMediaSetActionVariableToString, 1,
|
|
"(MediaHandler mh, QTAtomID variableID, Ptr theCString) -> (ComponentResult _rv)"},
|
|
{"SpriteMediaGetActionVariableAsString", (PyCFunction)Qt_SpriteMediaGetActionVariableAsString, 1,
|
|
"(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, Handle theCString)"},
|
|
{"FlashMediaSetPan", (PyCFunction)Qt_FlashMediaSetPan, 1,
|
|
"(MediaHandler mh, short xPercent, short yPercent) -> (ComponentResult _rv)"},
|
|
{"FlashMediaSetZoom", (PyCFunction)Qt_FlashMediaSetZoom, 1,
|
|
"(MediaHandler mh, short factor) -> (ComponentResult _rv)"},
|
|
{"FlashMediaSetZoomRect", (PyCFunction)Qt_FlashMediaSetZoomRect, 1,
|
|
"(MediaHandler mh, long left, long top, long right, long bottom) -> (ComponentResult _rv)"},
|
|
{"FlashMediaGetRefConBounds", (PyCFunction)Qt_FlashMediaGetRefConBounds, 1,
|
|
"(MediaHandler mh, long refCon) -> (ComponentResult _rv, long left, long top, long right, long bottom)"},
|
|
{"FlashMediaGetRefConID", (PyCFunction)Qt_FlashMediaGetRefConID, 1,
|
|
"(MediaHandler mh, long refCon) -> (ComponentResult _rv, long refConID)"},
|
|
{"FlashMediaIDToRefCon", (PyCFunction)Qt_FlashMediaIDToRefCon, 1,
|
|
"(MediaHandler mh, long refConID) -> (ComponentResult _rv, long refCon)"},
|
|
{"FlashMediaGetDisplayedFrameNumber", (PyCFunction)Qt_FlashMediaGetDisplayedFrameNumber, 1,
|
|
"(MediaHandler mh) -> (ComponentResult _rv, long flashFrameNumber)"},
|
|
{"FlashMediaFrameNumberToMovieTime", (PyCFunction)Qt_FlashMediaFrameNumberToMovieTime, 1,
|
|
"(MediaHandler mh, long flashFrameNumber) -> (ComponentResult _rv, TimeValue movieTime)"},
|
|
{"FlashMediaFrameLabelToMovieTime", (PyCFunction)Qt_FlashMediaFrameLabelToMovieTime, 1,
|
|
"(MediaHandler mh, Ptr theLabel) -> (ComponentResult _rv, TimeValue movieTime)"},
|
|
{"FlashMediaGetFlashVariable", (PyCFunction)Qt_FlashMediaGetFlashVariable, 1,
|
|
"(MediaHandler mh) -> (ComponentResult _rv, char path, char name, Handle theVariableCStringOut)"},
|
|
{"FlashMediaSetFlashVariable", (PyCFunction)Qt_FlashMediaSetFlashVariable, 1,
|
|
"(MediaHandler mh, Boolean updateFocus) -> (ComponentResult _rv, char path, char name, char value)"},
|
|
{"FlashMediaDoButtonActions", (PyCFunction)Qt_FlashMediaDoButtonActions, 1,
|
|
"(MediaHandler mh, long buttonID, long transition) -> (ComponentResult _rv, char path)"},
|
|
{"FlashMediaGetSupportedSwfVersion", (PyCFunction)Qt_FlashMediaGetSupportedSwfVersion, 1,
|
|
"(MediaHandler mh) -> (ComponentResult _rv, UInt8 swfVersion)"},
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
{"MovieMediaGetCurrentMovieProperty", (PyCFunction)Qt_MovieMediaGetCurrentMovieProperty, 1,
|
|
"(MediaHandler mh, OSType whichProperty, void * value) -> (ComponentResult _rv)"},
|
|
#endif
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
{"MovieMediaGetCurrentTrackProperty", (PyCFunction)Qt_MovieMediaGetCurrentTrackProperty, 1,
|
|
"(MediaHandler mh, long trackID, OSType whichProperty, void * value) -> (ComponentResult _rv)"},
|
|
#endif
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
{"MovieMediaGetChildMovieDataReference", (PyCFunction)Qt_MovieMediaGetChildMovieDataReference, 1,
|
|
"(MediaHandler mh, QTAtomID dataRefID, short dataRefIndex) -> (ComponentResult _rv, OSType dataRefType, Handle dataRef, QTAtomID dataRefIDOut, short dataRefIndexOut)"},
|
|
#endif
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
{"MovieMediaSetChildMovieDataReference", (PyCFunction)Qt_MovieMediaSetChildMovieDataReference, 1,
|
|
"(MediaHandler mh, QTAtomID dataRefID, OSType dataRefType, Handle dataRef) -> (ComponentResult _rv)"},
|
|
#endif
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
{"MovieMediaLoadChildMovieFromDataReference", (PyCFunction)Qt_MovieMediaLoadChildMovieFromDataReference, 1,
|
|
"(MediaHandler mh, QTAtomID dataRefID) -> (ComponentResult _rv)"},
|
|
#endif
|
|
{"Media3DGetCurrentGroup", (PyCFunction)Qt_Media3DGetCurrentGroup, 1,
|
|
"(MediaHandler mh, void * group) -> (ComponentResult _rv)"},
|
|
{"Media3DTranslateNamedObjectTo", (PyCFunction)Qt_Media3DTranslateNamedObjectTo, 1,
|
|
"(MediaHandler mh, Fixed x, Fixed y, Fixed z) -> (ComponentResult _rv, char objectName)"},
|
|
{"Media3DScaleNamedObjectTo", (PyCFunction)Qt_Media3DScaleNamedObjectTo, 1,
|
|
"(MediaHandler mh, Fixed xScale, Fixed yScale, Fixed zScale) -> (ComponentResult _rv, char objectName)"},
|
|
{"Media3DRotateNamedObjectTo", (PyCFunction)Qt_Media3DRotateNamedObjectTo, 1,
|
|
"(MediaHandler mh, Fixed xDegrees, Fixed yDegrees, Fixed zDegrees) -> (ComponentResult _rv, char objectName)"},
|
|
{"Media3DSetCameraData", (PyCFunction)Qt_Media3DSetCameraData, 1,
|
|
"(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)"},
|
|
{"Media3DGetCameraData", (PyCFunction)Qt_Media3DGetCameraData, 1,
|
|
"(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)"},
|
|
{"Media3DSetCameraAngleAspect", (PyCFunction)Qt_Media3DSetCameraAngleAspect, 1,
|
|
"(MediaHandler mh, QTFloatSingle fov, QTFloatSingle aspectRatioXToY) -> (ComponentResult _rv)"},
|
|
{"Media3DGetCameraAngleAspect", (PyCFunction)Qt_Media3DGetCameraAngleAspect, 1,
|
|
"(MediaHandler mh) -> (ComponentResult _rv, QTFloatSingle fov, QTFloatSingle aspectRatioXToY)"},
|
|
{"Media3DSetCameraRange", (PyCFunction)Qt_Media3DSetCameraRange, 1,
|
|
"(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)"},
|
|
{"Media3DGetCameraRange", (PyCFunction)Qt_Media3DGetCameraRange, 1,
|
|
"(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)"},
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
{"Media3DGetViewObject", (PyCFunction)Qt_Media3DGetViewObject, 1,
|
|
"(MediaHandler mh, void * tq3viewObject) -> (ComponentResult _rv)"},
|
|
#endif
|
|
{"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1,
|
|
"() -> (TimeBase _rv)"},
|
|
{"ConvertTime", (PyCFunction)Qt_ConvertTime, 1,
|
|
"(TimeBase newBase) -> (TimeRecord theTime)"},
|
|
{"ConvertTimeScale", (PyCFunction)Qt_ConvertTimeScale, 1,
|
|
"(TimeScale newScale) -> (TimeRecord theTime)"},
|
|
{"AddTime", (PyCFunction)Qt_AddTime, 1,
|
|
"(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)"},
|
|
{"SubtractTime", (PyCFunction)Qt_SubtractTime, 1,
|
|
"(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)"},
|
|
{"MusicMediaGetIndexedTunePlayer", (PyCFunction)Qt_MusicMediaGetIndexedTunePlayer, 1,
|
|
"(ComponentInstance ti, long sampleDescIndex) -> (ComponentResult _rv, ComponentInstance tp)"},
|
|
{"AlignWindow", (PyCFunction)Qt_AlignWindow, 1,
|
|
"(WindowPtr wp, Boolean front) -> None"},
|
|
{"DragAlignedWindow", (PyCFunction)Qt_DragAlignedWindow, 1,
|
|
"(WindowPtr wp, Point startPt, Rect boundsRect) -> None"},
|
|
{"MoviesTask", (PyCFunction)Qt_MoviesTask, 1,
|
|
"(long maxMilliSecToUse) -> None"},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
|
|
|
|
|
|
void init_Qt(void)
|
|
{
|
|
PyObject *m;
|
|
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);
|
|
|
|
|
|
m = Py_InitModule("_Qt", Qt_methods);
|
|
d = PyModule_GetDict(m);
|
|
Qt_Error = PyMac_GetOSErrException();
|
|
if (Qt_Error == NULL ||
|
|
PyDict_SetItemString(d, "Error", Qt_Error) != 0)
|
|
return;
|
|
MovieController_Type.ob_type = &PyType_Type;
|
|
Py_INCREF(&MovieController_Type);
|
|
if (PyDict_SetItemString(d, "MovieControllerType", (PyObject *)&MovieController_Type) != 0)
|
|
Py_FatalError("can't initialize MovieControllerType");
|
|
TimeBase_Type.ob_type = &PyType_Type;
|
|
Py_INCREF(&TimeBase_Type);
|
|
if (PyDict_SetItemString(d, "TimeBaseType", (PyObject *)&TimeBase_Type) != 0)
|
|
Py_FatalError("can't initialize TimeBaseType");
|
|
UserData_Type.ob_type = &PyType_Type;
|
|
Py_INCREF(&UserData_Type);
|
|
if (PyDict_SetItemString(d, "UserDataType", (PyObject *)&UserData_Type) != 0)
|
|
Py_FatalError("can't initialize UserDataType");
|
|
Media_Type.ob_type = &PyType_Type;
|
|
Py_INCREF(&Media_Type);
|
|
if (PyDict_SetItemString(d, "MediaType", (PyObject *)&Media_Type) != 0)
|
|
Py_FatalError("can't initialize MediaType");
|
|
Track_Type.ob_type = &PyType_Type;
|
|
Py_INCREF(&Track_Type);
|
|
if (PyDict_SetItemString(d, "TrackType", (PyObject *)&Track_Type) != 0)
|
|
Py_FatalError("can't initialize TrackType");
|
|
Movie_Type.ob_type = &PyType_Type;
|
|
Py_INCREF(&Movie_Type);
|
|
if (PyDict_SetItemString(d, "MovieType", (PyObject *)&Movie_Type) != 0)
|
|
Py_FatalError("can't initialize MovieType");
|
|
}
|
|
|
|
/* ========================= End module _Qt ========================= */
|
|
|