staticforward int TrackObj_Convert(PyObject *, Track *);
staticforward PyObject *MovieObj_New(Movie);
staticforward int MovieObj_Convert(PyObject *, Movie *);
+staticforward PyObject *MovieCtlObj_New(MovieController);
+staticforward int MovieCtlObj_Convert(PyObject *, MovieController *);
static PyObject *Qt_Error;
-/* ---------------------- Object type TimeBase ---------------------- */
+/* ------------------ Object type MovieController ------------------- */
-PyTypeObject TimeBase_Type;
+PyTypeObject MovieController_Type;
-#define TimeBaseObj_Check(x) ((x)->ob_type == &TimeBase_Type)
+#define MovieCtlObj_Check(x) ((x)->ob_type == &MovieController_Type)
-typedef struct TimeBaseObject {
+typedef struct MovieControllerObject {
PyObject_HEAD
- TimeBase ob_itself;
-} TimeBaseObject;
+ MovieController ob_itself;
+} MovieControllerObject;
-PyObject *TimeBaseObj_New(itself)
- TimeBase itself;
+PyObject *MovieCtlObj_New(itself)
+ MovieController itself;
{
- TimeBaseObject *it;
+ MovieControllerObject *it;
if (itself == NULL) {
- PyErr_SetString(Qt_Error,"Cannot create null TimeBase");
+ PyErr_SetString(Qt_Error,"Cannot create null MovieController");
return NULL;
}
- it = PyObject_NEW(TimeBaseObject, &TimeBase_Type);
+ it = PyObject_NEW(MovieControllerObject, &MovieController_Type);
if (it == NULL) return NULL;
it->ob_itself = itself;
return (PyObject *)it;
}
-TimeBaseObj_Convert(v, p_itself)
+MovieCtlObj_Convert(v, p_itself)
PyObject *v;
- TimeBase *p_itself;
+ MovieController *p_itself;
{
- if (!TimeBaseObj_Check(v))
+ if (!MovieCtlObj_Check(v))
{
- PyErr_SetString(PyExc_TypeError, "TimeBase required");
+ PyErr_SetString(PyExc_TypeError, "MovieController required");
return 0;
}
- *p_itself = ((TimeBaseObject *)v)->ob_itself;
+ *p_itself = ((MovieControllerObject *)v)->ob_itself;
return 1;
}
-static void TimeBaseObj_dealloc(self)
- TimeBaseObject *self;
+static void MovieCtlObj_dealloc(self)
+ MovieControllerObject *self;
{
- DisposeTimeBase(self->ob_itself);
+ DisposeMovieController(self->ob_itself);
PyMem_DEL(self);
}
-static PyObject *TimeBaseObj_SetTimeBaseValue(_self, _args)
- TimeBaseObject *_self;
+static PyObject *MovieCtlObj_MCSetMovie(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue t;
- TimeScale s;
- if (!PyArg_ParseTuple(_args, "ll",
- &t,
- &s))
+ ComponentResult _rv;
+ Movie theMovie;
+ WindowPtr movieWindow;
+ Point where;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ MovieObj_Convert, &theMovie,
+ WinObj_Convert, &movieWindow,
+ PyMac_GetPoint, &where))
return NULL;
- SetTimeBaseValue(_self->ob_itself,
- t,
- s);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = MCSetMovie(_self->ob_itself,
+ theMovie,
+ movieWindow,
+ where);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *TimeBaseObj_GetTimeBaseRate(_self, _args)
- TimeBaseObject *_self;
+static PyObject *MovieCtlObj_MCGetIndMovie(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Fixed _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ Movie _rv;
+ short index;
+ if (!PyArg_ParseTuple(_args, "h",
+ &index))
return NULL;
- _rv = GetTimeBaseRate(_self->ob_itself);
+ _rv = MCGetIndMovie(_self->ob_itself,
+ index);
_res = Py_BuildValue("O&",
- PyMac_BuildFixed, _rv);
+ MovieObj_New, _rv);
return _res;
}
-static PyObject *TimeBaseObj_SetTimeBaseRate(_self, _args)
- TimeBaseObject *_self;
+static PyObject *MovieCtlObj_MCRemoveMovie(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Fixed r;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetFixed, &r))
+ ComponentResult _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SetTimeBaseRate(_self->ob_itself,
- r);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = MCRemoveMovie(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *TimeBaseObj_GetTimeBaseFlags(_self, _args)
- TimeBaseObject *_self;
+static PyObject *MovieCtlObj_MCIsPlayerEvent(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ ComponentResult _rv;
+ EventRecord e;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &e))
return NULL;
- _rv = GetTimeBaseFlags(_self->ob_itself);
+ _rv = MCIsPlayerEvent(_self->ob_itself,
+ &e);
_res = Py_BuildValue("l",
_rv);
return _res;
}
-static PyObject *TimeBaseObj_SetTimeBaseFlags(_self, _args)
- TimeBaseObject *_self;
+static PyObject *MovieCtlObj_MCDoAction(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long timeBaseFlags;
- if (!PyArg_ParseTuple(_args, "l",
- &timeBaseFlags))
- return NULL;
- SetTimeBaseFlags(_self->ob_itself,
- timeBaseFlags);
- Py_INCREF(Py_None);
- _res = Py_None;
+ ComponentResult _rv;
+ short action;
+ void * params;
+ 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 *TimeBaseObj_GetTimeBaseMasterTimeBase(_self, _args)
- TimeBaseObject *_self;
+static PyObject *MovieCtlObj_MCSetControllerAttached(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeBase _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ ComponentResult _rv;
+ Boolean attach;
+ if (!PyArg_ParseTuple(_args, "b",
+ &attach))
return NULL;
- _rv = GetTimeBaseMasterTimeBase(_self->ob_itself);
- _res = Py_BuildValue("O&",
- TimeBaseObj_New, _rv);
+ _rv = MCSetControllerAttached(_self->ob_itself,
+ attach);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *TimeBaseObj_GetTimeBaseMasterClock(_self, _args)
- TimeBaseObject *_self;
+static PyObject *MovieCtlObj_MCIsControllerAttached(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentInstance _rv;
+ ComponentResult _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTimeBaseMasterClock(_self->ob_itself);
- _res = Py_BuildValue("O&",
- CmpInstObj_New, _rv);
+ _rv = MCIsControllerAttached(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *TimeBaseObj_GetTimeBaseEffectiveRate(_self, _args)
- TimeBaseObject *_self;
+static PyObject *MovieCtlObj_MCSetVisible(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Fixed _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ ComponentResult _rv;
+ Boolean visible;
+ if (!PyArg_ParseTuple(_args, "b",
+ &visible))
return NULL;
- _rv = GetTimeBaseEffectiveRate(_self->ob_itself);
- _res = Py_BuildValue("O&",
- PyMac_BuildFixed, _rv);
+ _rv = MCSetVisible(_self->ob_itself,
+ visible);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyMethodDef TimeBaseObj_methods[] = {
- {"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"},
- {"GetTimeBaseFlags", (PyCFunction)TimeBaseObj_GetTimeBaseFlags, 1,
- "() -> (long _rv)"},
- {"SetTimeBaseFlags", (PyCFunction)TimeBaseObj_SetTimeBaseFlags, 1,
- "(long timeBaseFlags) -> None"},
- {"GetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_GetTimeBaseMasterTimeBase, 1,
- "() -> (TimeBase _rv)"},
- {"GetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_GetTimeBaseMasterClock, 1,
- "() -> (ComponentInstance _rv)"},
- {"GetTimeBaseEffectiveRate", (PyCFunction)TimeBaseObj_GetTimeBaseEffectiveRate, 1,
- "() -> (Fixed _rv)"},
- {NULL, NULL, 0}
-};
-
-PyMethodChain TimeBaseObj_chain = { TimeBaseObj_methods, NULL };
-
-static PyObject *TimeBaseObj_getattr(self, name)
- TimeBaseObject *self;
- char *name;
+static PyObject *MovieCtlObj_MCGetVisible(_self, _args)
+ MovieControllerObject *_self;
+ PyObject *_args;
{
- return Py_FindMethodInChain(&TimeBaseObj_chain, (PyObject *)self, name);
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCGetVisible(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
}
-#define TimeBaseObj_setattr NULL
-
-PyTypeObject TimeBase_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
- 0, /*ob_size*/
- "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*/
-};
-
-/* -------------------- 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(itself)
- UserData itself;
+static PyObject *MovieCtlObj_MCGetControllerBoundsRect(_self, _args)
+ MovieControllerObject *_self;
+ PyObject *_args;
{
- 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;
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Rect bounds;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCGetControllerBoundsRect(_self->ob_itself,
+ &bounds);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ PyMac_BuildRect, &bounds);
+ return _res;
}
-UserDataObj_Convert(v, p_itself)
- PyObject *v;
- UserData *p_itself;
+
+static PyObject *MovieCtlObj_MCSetControllerBoundsRect(_self, _args)
+ MovieControllerObject *_self;
+ PyObject *_args;
{
- if (!UserDataObj_Check(v))
- {
- PyErr_SetString(PyExc_TypeError, "UserData required");
- return 0;
- }
- *p_itself = ((UserDataObject *)v)->ob_itself;
- return 1;
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Rect bounds;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &bounds))
+ return NULL;
+ _rv = MCSetControllerBoundsRect(_self->ob_itself,
+ &bounds);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
}
-static void UserDataObj_dealloc(self)
- UserDataObject *self;
+static PyObject *MovieCtlObj_MCGetControllerBoundsRgn(_self, _args)
+ MovieControllerObject *_self;
+ PyObject *_args;
{
- DisposeUserData(self->ob_itself);
- PyMem_DEL(self);
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCGetControllerBoundsRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
}
-static PyObject *UserDataObj_GetUserData(_self, _args)
- UserDataObject *_self;
+static PyObject *MovieCtlObj_MCGetWindowRgn(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- Handle data;
- OSType udType;
- long index;
- if (!PyArg_ParseTuple(_args, "O&O&l",
- ResObj_Convert, &data,
- PyMac_GetOSType, &udType,
- &index))
+ RgnHandle _rv;
+ WindowPtr w;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &w))
return NULL;
- _err = GetUserData(_self->ob_itself,
- data,
- udType,
- index);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = MCGetWindowRgn(_self->ob_itself,
+ w);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
return _res;
}
-static PyObject *UserDataObj_AddUserData(_self, _args)
- UserDataObject *_self;
+static PyObject *MovieCtlObj_MCMovieChanged(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- Handle data;
- OSType udType;
- if (!PyArg_ParseTuple(_args, "O&O&",
- ResObj_Convert, &data,
- PyMac_GetOSType, &udType))
+ ComponentResult _rv;
+ Movie m;
+ if (!PyArg_ParseTuple(_args, "O&",
+ MovieObj_Convert, &m))
return NULL;
- _err = AddUserData(_self->ob_itself,
- data,
- udType);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = MCMovieChanged(_self->ob_itself,
+ m);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *UserDataObj_RemoveUserData(_self, _args)
- UserDataObject *_self;
+static PyObject *MovieCtlObj_MCSetDuration(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- OSType udType;
- long index;
- if (!PyArg_ParseTuple(_args, "O&l",
- PyMac_GetOSType, &udType,
- &index))
+ ComponentResult _rv;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "l",
+ &duration))
return NULL;
- _err = RemoveUserData(_self->ob_itself,
- udType,
- index);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = MCSetDuration(_self->ob_itself,
+ duration);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *UserDataObj_CountUserDataType(_self, _args)
- UserDataObject *_self;
+static PyObject *MovieCtlObj_MCGetCurrentTime(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short _rv;
- OSType udType;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetOSType, &udType))
+ TimeValue _rv;
+ TimeScale scale;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = CountUserDataType(_self->ob_itself,
- udType);
- _res = Py_BuildValue("h",
+ _rv = MCGetCurrentTime(_self->ob_itself,
+ &scale);
+ _res = Py_BuildValue("ll",
+ _rv,
+ scale);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCNewAttachedController(_self, _args)
+ MovieControllerObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Movie theMovie;
+ WindowPtr w;
+ Point where;
+ 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 *UserDataObj_GetNextUserDataType(_self, _args)
- UserDataObject *_self;
+static PyObject *MovieCtlObj_MCDraw(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long _rv;
- OSType udType;
+ ComponentResult _rv;
+ WindowPtr w;
if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetOSType, &udType))
+ WinObj_Convert, &w))
return NULL;
- _rv = GetNextUserDataType(_self->ob_itself,
- udType);
+ _rv = MCDraw(_self->ob_itself,
+ w);
_res = Py_BuildValue("l",
_rv);
return _res;
}
-static PyObject *UserDataObj_AddUserDataText(_self, _args)
- UserDataObject *_self;
+static PyObject *MovieCtlObj_MCActivate(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- Handle data;
- OSType udType;
- long index;
- short itlRegionTag;
- if (!PyArg_ParseTuple(_args, "O&O&lh",
- ResObj_Convert, &data,
- PyMac_GetOSType, &udType,
- &index,
- &itlRegionTag))
+ ComponentResult _rv;
+ WindowPtr w;
+ Boolean activate;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ WinObj_Convert, &w,
+ &activate))
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;
+ _rv = MCActivate(_self->ob_itself,
+ w,
+ activate);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *UserDataObj_GetUserDataText(_self, _args)
- UserDataObject *_self;
+static PyObject *MovieCtlObj_MCIdle(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- Handle data;
- OSType udType;
- long index;
- short itlRegionTag;
- if (!PyArg_ParseTuple(_args, "O&O&lh",
- ResObj_Convert, &data,
- PyMac_GetOSType, &udType,
- &index,
- &itlRegionTag))
+ ComponentResult _rv;
+ if (!PyArg_ParseTuple(_args, ""))
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;
+ _rv = MCIdle(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *UserDataObj_RemoveUserDataText(_self, _args)
- UserDataObject *_self;
+static PyObject *MovieCtlObj_MCKey(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- OSType udType;
- long index;
- short itlRegionTag;
- if (!PyArg_ParseTuple(_args, "O&lh",
- PyMac_GetOSType, &udType,
- &index,
- &itlRegionTag))
+ ComponentResult _rv;
+ SInt8 key;
+ long modifiers;
+ if (!PyArg_ParseTuple(_args, "bl",
+ &key,
+ &modifiers))
return NULL;
- _err = RemoveUserDataText(_self->ob_itself,
- udType,
- index,
- itlRegionTag);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = MCKey(_self->ob_itself,
+ key,
+ modifiers);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *UserDataObj_PutUserDataIntoHandle(_self, _args)
- UserDataObject *_self;
+static PyObject *MovieCtlObj_MCClick(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- Handle h;
- if (!PyArg_ParseTuple(_args, "O&",
- ResObj_Convert, &h))
+ ComponentResult _rv;
+ WindowPtr w;
+ Point where;
+ long when;
+ long modifiers;
+ if (!PyArg_ParseTuple(_args, "O&O&ll",
+ WinObj_Convert, &w,
+ PyMac_GetPoint, &where,
+ &when,
+ &modifiers))
return NULL;
- _err = PutUserDataIntoHandle(_self->ob_itself,
- h);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = MCClick(_self->ob_itself,
+ w,
+ where,
+ when,
+ modifiers);
+ _res = Py_BuildValue("l",
+ _rv);
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(self, name)
- UserDataObject *self;
- char *name;
+static PyObject *MovieCtlObj_MCEnableEditing(_self, _args)
+ MovieControllerObject *_self;
+ PyObject *_args;
{
- return Py_FindMethodInChain(&UserDataObj_chain, (PyObject *)self, name);
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Boolean enabled;
+ if (!PyArg_ParseTuple(_args, "b",
+ &enabled))
+ return NULL;
+ _rv = MCEnableEditing(_self->ob_itself,
+ enabled);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
}
-#define UserDataObj_setattr NULL
-
-PyTypeObject UserData_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
- 0, /*ob_size*/
- "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*/
-};
-
-/* -------------------- 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(itself)
- 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;
-}
-MediaObj_Convert(v, p_itself)
- 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(self)
- MediaObject *self;
-{
- DisposeTrackMedia(self->ob_itself);
- PyMem_DEL(self);
-}
-
-static PyObject *MediaObj_LoadMediaIntoRam(_self, _args)
- MediaObject *_self;
+static PyObject *MovieCtlObj_MCIsEditingEnabled(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- TimeValue time;
- TimeValue duration;
- long flags;
- if (!PyArg_ParseTuple(_args, "lll",
- &time,
- &duration,
- &flags))
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _err = LoadMediaIntoRam(_self->ob_itself,
- time,
- duration,
- flags);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = MCIsEditingEnabled(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *MediaObj_GetMediaTrack(_self, _args)
- MediaObject *_self;
+static PyObject *MovieCtlObj_MCCopy(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Track _rv;
+ Movie _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMediaTrack(_self->ob_itself);
+ _rv = MCCopy(_self->ob_itself);
_res = Py_BuildValue("O&",
- TrackObj_New, _rv);
+ MovieObj_New, _rv);
return _res;
}
-static PyObject *MediaObj_GetMediaTimeScale(_self, _args)
- MediaObject *_self;
+static PyObject *MovieCtlObj_MCCut(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeScale _rv;
+ Movie _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMediaTimeScale(_self->ob_itself);
- _res = Py_BuildValue("l",
- _rv);
+ _rv = MCCut(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
return _res;
}
-static PyObject *MediaObj_SetMediaTimeScale(_self, _args)
- MediaObject *_self;
+static PyObject *MovieCtlObj_MCPaste(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeScale timeScale;
- if (!PyArg_ParseTuple(_args, "l",
- &timeScale))
+ ComponentResult _rv;
+ Movie srcMovie;
+ if (!PyArg_ParseTuple(_args, "O&",
+ MovieObj_Convert, &srcMovie))
return NULL;
- SetMediaTimeScale(_self->ob_itself,
- timeScale);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = MCPaste(_self->ob_itself,
+ srcMovie);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *MediaObj_GetMediaDuration(_self, _args)
- MediaObject *_self;
+static PyObject *MovieCtlObj_MCClear(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue _rv;
+ ComponentResult _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMediaDuration(_self->ob_itself);
+ _rv = MCClear(_self->ob_itself);
_res = Py_BuildValue("l",
_rv);
return _res;
}
-static PyObject *MediaObj_GetMediaLanguage(_self, _args)
- MediaObject *_self;
+static PyObject *MovieCtlObj_MCUndo(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short _rv;
+ ComponentResult _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMediaLanguage(_self->ob_itself);
- _res = Py_BuildValue("h",
+ _rv = MCUndo(_self->ob_itself);
+ _res = Py_BuildValue("l",
_rv);
return _res;
}
-static PyObject *MediaObj_SetMediaLanguage(_self, _args)
- MediaObject *_self;
+static PyObject *MovieCtlObj_MCPositionController(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short language;
- if (!PyArg_ParseTuple(_args, "h",
- &language))
+ ComponentResult _rv;
+ Rect movieRect;
+ Rect controllerRect;
+ long someFlags;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ PyMac_GetRect, &movieRect,
+ PyMac_GetRect, &controllerRect,
+ &someFlags))
return NULL;
- SetMediaLanguage(_self->ob_itself,
- language);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = MCPositionController(_self->ob_itself,
+ &movieRect,
+ &controllerRect,
+ someFlags);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *MediaObj_GetMediaQuality(_self, _args)
- MediaObject *_self;
+static PyObject *MovieCtlObj_MCGetControllerInfo(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short _rv;
+ ComponentResult _rv;
+ long someFlags;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMediaQuality(_self->ob_itself);
- _res = Py_BuildValue("h",
- _rv);
+ _rv = MCGetControllerInfo(_self->ob_itself,
+ &someFlags);
+ _res = Py_BuildValue("ll",
+ _rv,
+ someFlags);
return _res;
}
-static PyObject *MediaObj_SetMediaQuality(_self, _args)
- MediaObject *_self;
+static PyObject *MovieCtlObj_MCSetClip(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short quality;
- if (!PyArg_ParseTuple(_args, "h",
- &quality))
+ ComponentResult _rv;
+ RgnHandle theClip;
+ RgnHandle movieClip;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &theClip,
+ ResObj_Convert, &movieClip))
return NULL;
- SetMediaQuality(_self->ob_itself,
- quality);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = MCSetClip(_self->ob_itself,
+ theClip,
+ movieClip);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *MediaObj_GetMediaHandlerDescription(_self, _args)
- MediaObject *_self;
+static PyObject *MovieCtlObj_MCGetClip(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSType mediaType;
- Str255 creatorName;
- OSType creatorManufacturer;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetStr255, creatorName))
+ ComponentResult _rv;
+ RgnHandle theClip;
+ RgnHandle movieClip;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- GetMediaHandlerDescription(_self->ob_itself,
- &mediaType,
- creatorName,
- &creatorManufacturer);
- _res = Py_BuildValue("O&O&",
- PyMac_BuildOSType, mediaType,
- PyMac_BuildOSType, creatorManufacturer);
+ _rv = MCGetClip(_self->ob_itself,
+ &theClip,
+ &movieClip);
+ _res = Py_BuildValue("lO&O&",
+ _rv,
+ ResObj_New, theClip,
+ ResObj_New, movieClip);
return _res;
}
-static PyObject *MediaObj_GetMediaUserData(_self, _args)
- MediaObject *_self;
+static PyObject *MovieCtlObj_MCDrawBadge(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- UserData _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ ComponentResult _rv;
+ RgnHandle movieRgn;
+ RgnHandle badgeRgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &movieRgn))
return NULL;
- _rv = GetMediaUserData(_self->ob_itself);
- _res = Py_BuildValue("O&",
- UserDataObj_New, _rv);
+ _rv = MCDrawBadge(_self->ob_itself,
+ movieRgn,
+ &badgeRgn);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ ResObj_New, badgeRgn);
return _res;
}
-static PyObject *MediaObj_GetMediaHandler(_self, _args)
- MediaObject *_self;
+static PyObject *MovieCtlObj_MCSetUpEditMenu(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- MediaHandler _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ ComponentResult _rv;
+ long modifiers;
+ MenuHandle mh;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &modifiers,
+ MenuObj_Convert, &mh))
return NULL;
- _rv = GetMediaHandler(_self->ob_itself);
- _res = Py_BuildValue("O&",
- CmpInstObj_New, _rv);
+ _rv = MCSetUpEditMenu(_self->ob_itself,
+ modifiers,
+ mh);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *MediaObj_SetMediaHandler(_self, _args)
- MediaObject *_self;
+static PyObject *MovieCtlObj_MCGetMenuString(_self, _args)
+ MovieControllerObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- MediaHandlerComponent mH;
- if (!PyArg_ParseTuple(_args, "O&",
- CmpObj_Convert, &mH))
+ ComponentResult _rv;
+ long modifiers;
+ short item;
+ Str255 aString;
+ if (!PyArg_ParseTuple(_args, "lhO&",
+ &modifiers,
+ &item,
+ PyMac_GetStr255, aString))
return NULL;
- _err = SetMediaHandler(_self->ob_itself,
- mH);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = MCGetMenuString(_self->ob_itself,
+ modifiers,
+ item,
+ aString);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *MediaObj_BeginMediaEdits(_self, _args)
- MediaObject *_self;
- PyObject *_args;
+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)"},
+ {"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)"},
+ {"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)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain MovieCtlObj_chain = { MovieCtlObj_methods, NULL };
+
+static PyObject *MovieCtlObj_getattr(self, name)
+ MovieControllerObject *self;
+ char *name;
{
- PyObject *_res = NULL;
- OSErr _err;
- 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;
+ return Py_FindMethodInChain(&MovieCtlObj_chain, (PyObject *)self, name);
}
-static PyObject *MediaObj_EndMediaEdits(_self, _args)
- MediaObject *_self;
- PyObject *_args;
+#define MovieCtlObj_setattr NULL
+
+PyTypeObject MovieController_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "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*/
+};
+
+/* ---------------- 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(itself)
+ TimeBase itself;
{
- PyObject *_res = NULL;
- OSErr _err;
- 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;
+ 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;
+}
+TimeBaseObj_Convert(v, p_itself)
+ 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 PyObject *MediaObj_SetMediaDefaultDataRefIndex(_self, _args)
- MediaObject *_self;
- PyObject *_args;
+static void TimeBaseObj_dealloc(self)
+ TimeBaseObject *self;
{
- PyObject *_res = NULL;
- OSErr _err;
- short index;
- 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;
+ DisposeTimeBase(self->ob_itself);
+ PyMem_DEL(self);
}
-static PyObject *MediaObj_GetMediaDataHandlerDescription(_self, _args)
- MediaObject *_self;
+static PyObject *TimeBaseObj_SetTimeBaseValue(_self, _args)
+ TimeBaseObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short index;
- OSType dhType;
- Str255 creatorName;
- OSType creatorManufacturer;
- if (!PyArg_ParseTuple(_args, "hO&",
- &index,
- PyMac_GetStr255, creatorName))
+ TimeValue t;
+ TimeScale s;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &t,
+ &s))
return NULL;
- GetMediaDataHandlerDescription(_self->ob_itself,
- index,
- &dhType,
- creatorName,
- &creatorManufacturer);
- _res = Py_BuildValue("O&O&",
- PyMac_BuildOSType, dhType,
- PyMac_BuildOSType, creatorManufacturer);
+ SetTimeBaseValue(_self->ob_itself,
+ t,
+ s);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MediaObj_GetMediaDataHandler(_self, _args)
- MediaObject *_self;
+static PyObject *TimeBaseObj_GetTimeBaseRate(_self, _args)
+ TimeBaseObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- DataHandler _rv;
- short index;
- if (!PyArg_ParseTuple(_args, "h",
- &index))
+ Fixed _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMediaDataHandler(_self->ob_itself,
- index);
+ _rv = GetTimeBaseRate(_self->ob_itself);
_res = Py_BuildValue("O&",
- CmpInstObj_New, _rv);
+ PyMac_BuildFixed, _rv);
return _res;
}
-static PyObject *MediaObj_SetMediaDataHandler(_self, _args)
- MediaObject *_self;
+static PyObject *TimeBaseObj_SetTimeBaseRate(_self, _args)
+ TimeBaseObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- short index;
- DataHandlerComponent dataHandler;
- if (!PyArg_ParseTuple(_args, "hO&",
- &index,
- CmpObj_Convert, &dataHandler))
+ Fixed r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFixed, &r))
return NULL;
- _err = SetMediaDataHandler(_self->ob_itself,
- index,
- dataHandler);
- if (_err != noErr) return PyMac_Error(_err);
+ SetTimeBaseRate(_self->ob_itself,
+ r);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MediaObj_GetMediaSampleDescriptionCount(_self, _args)
- MediaObject *_self;
+static PyObject *TimeBaseObj_GetTimeBaseFlags(_self, _args)
+ TimeBaseObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
long _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMediaSampleDescriptionCount(_self->ob_itself);
+ _rv = GetTimeBaseFlags(_self->ob_itself);
_res = Py_BuildValue("l",
_rv);
return _res;
}
-static PyObject *MediaObj_GetMediaSampleDescription(_self, _args)
- MediaObject *_self;
+static PyObject *TimeBaseObj_SetTimeBaseFlags(_self, _args)
+ TimeBaseObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long index;
- SampleDescriptionHandle descH;
- if (!PyArg_ParseTuple(_args, "lO&",
- &index,
- ResObj_Convert, &descH))
+ long timeBaseFlags;
+ if (!PyArg_ParseTuple(_args, "l",
+ &timeBaseFlags))
return NULL;
- GetMediaSampleDescription(_self->ob_itself,
- index,
- descH);
+ SetTimeBaseFlags(_self->ob_itself,
+ timeBaseFlags);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MediaObj_SetMediaSampleDescription(_self, _args)
- MediaObject *_self;
+static PyObject *TimeBaseObj_GetTimeBaseMasterTimeBase(_self, _args)
+ TimeBaseObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- long index;
- SampleDescriptionHandle descH;
- if (!PyArg_ParseTuple(_args, "lO&",
- &index,
- ResObj_Convert, &descH))
+ TimeBase _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _err = SetMediaSampleDescription(_self->ob_itself,
- index,
- descH);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetTimeBaseMasterTimeBase(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ TimeBaseObj_New, _rv);
return _res;
}
-static PyObject *MediaObj_GetMediaSampleCount(_self, _args)
- MediaObject *_self;
+static PyObject *TimeBaseObj_GetTimeBaseMasterClock(_self, _args)
+ TimeBaseObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long _rv;
+ ComponentInstance _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMediaSampleCount(_self->ob_itself);
- _res = Py_BuildValue("l",
- _rv);
+ _rv = GetTimeBaseMasterClock(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CmpInstObj_New, _rv);
return _res;
}
-static PyObject *MediaObj_SampleNumToMediaTime(_self, _args)
- MediaObject *_self;
+static PyObject *TimeBaseObj_GetTimeBaseEffectiveRate(_self, _args)
+ TimeBaseObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long logicalSampleNum;
- TimeValue sampleTime;
- TimeValue sampleDuration;
- if (!PyArg_ParseTuple(_args, "l",
- &logicalSampleNum))
+ Fixed _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SampleNumToMediaTime(_self->ob_itself,
- logicalSampleNum,
- &sampleTime,
- &sampleDuration);
- _res = Py_BuildValue("ll",
- sampleTime,
- sampleDuration);
+ _rv = GetTimeBaseEffectiveRate(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildFixed, _rv);
return _res;
}
-static PyObject *MediaObj_MediaTimeToSampleNum(_self, _args)
- MediaObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- TimeValue time;
- long sampleNum;
- TimeValue sampleTime;
- TimeValue sampleDuration;
- 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 PyMethodDef TimeBaseObj_methods[] = {
+ {"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"},
+ {"GetTimeBaseFlags", (PyCFunction)TimeBaseObj_GetTimeBaseFlags, 1,
+ "() -> (long _rv)"},
+ {"SetTimeBaseFlags", (PyCFunction)TimeBaseObj_SetTimeBaseFlags, 1,
+ "(long timeBaseFlags) -> None"},
+ {"GetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_GetTimeBaseMasterTimeBase, 1,
+ "() -> (TimeBase _rv)"},
+ {"GetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_GetTimeBaseMasterClock, 1,
+ "() -> (ComponentInstance _rv)"},
+ {"GetTimeBaseEffectiveRate", (PyCFunction)TimeBaseObj_GetTimeBaseEffectiveRate, 1,
+ "() -> (Fixed _rv)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain TimeBaseObj_chain = { TimeBaseObj_methods, NULL };
+
+static PyObject *TimeBaseObj_getattr(self, name)
+ TimeBaseObject *self;
+ char *name;
+{
+ return Py_FindMethodInChain(&TimeBaseObj_chain, (PyObject *)self, name);
}
-static PyObject *MediaObj_AddMediaSample(_self, _args)
- MediaObject *_self;
+#define TimeBaseObj_setattr NULL
+
+PyTypeObject TimeBase_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "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*/
+};
+
+/* -------------------- 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(itself)
+ 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;
+}
+UserDataObj_Convert(v, p_itself)
+ 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(self)
+ UserDataObject *self;
+{
+ DisposeUserData(self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *UserDataObj_GetUserData(_self, _args)
+ UserDataObject *_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;
- if (!PyArg_ParseTuple(_args, "O&lllO&lh",
- ResObj_Convert, &dataIn,
- &inOffset,
- &size,
- &durationPerSample,
- ResObj_Convert, &sampleDescriptionH,
- &numberOfSamples,
- &sampleFlags))
+ Handle data;
+ OSType udType;
+ long index;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ ResObj_Convert, &data,
+ PyMac_GetOSType, &udType,
+ &index))
return NULL;
- _err = AddMediaSample(_self->ob_itself,
- dataIn,
- inOffset,
- size,
- durationPerSample,
- sampleDescriptionH,
- numberOfSamples,
- sampleFlags,
- &sampleTime);
+ _err = GetUserData(_self->ob_itself,
+ data,
+ udType,
+ index);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("l",
- sampleTime);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MediaObj_AddMediaSampleReference(_self, _args)
- MediaObject *_self;
+static PyObject *UserDataObj_AddUserData(_self, _args)
+ UserDataObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- long dataOffset;
- unsigned long size;
- TimeValue durationPerSample;
- SampleDescriptionHandle sampleDescriptionH;
- long numberOfSamples;
- short sampleFlags;
- TimeValue sampleTime;
- if (!PyArg_ParseTuple(_args, "lllO&lh",
- &dataOffset,
- &size,
- &durationPerSample,
- ResObj_Convert, &sampleDescriptionH,
- &numberOfSamples,
- &sampleFlags))
+ Handle data;
+ OSType udType;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &data,
+ PyMac_GetOSType, &udType))
return NULL;
- _err = AddMediaSampleReference(_self->ob_itself,
- dataOffset,
- size,
- durationPerSample,
- sampleDescriptionH,
- numberOfSamples,
- sampleFlags,
- &sampleTime);
+ _err = AddUserData(_self->ob_itself,
+ data,
+ udType);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("l",
- sampleTime);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MediaObj_GetMediaSample(_self, _args)
- MediaObject *_self;
+static PyObject *UserDataObj_RemoveUserData(_self, _args)
+ UserDataObject *_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;
- if (!PyArg_ParseTuple(_args, "O&llO&l",
- ResObj_Convert, &dataOut,
- &maxSizeToGrow,
- &time,
- ResObj_Convert, &sampleDescriptionH,
- &maxNumberOfSamples))
+ OSType udType;
+ long index;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetOSType, &udType,
+ &index))
return NULL;
- _err = GetMediaSample(_self->ob_itself,
- dataOut,
- maxSizeToGrow,
- &size,
- time,
- &sampleTime,
- &durationPerSample,
- sampleDescriptionH,
- &sampleDescriptionIndex,
- maxNumberOfSamples,
- &numberOfSamples,
- &sampleFlags);
+ _err = RemoveUserData(_self->ob_itself,
+ udType,
+ index);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("lllllh",
- size,
- sampleTime,
- durationPerSample,
- sampleDescriptionIndex,
- numberOfSamples,
- sampleFlags);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MediaObj_GetMediaSampleReference(_self, _args)
- MediaObject *_self;
+static PyObject *UserDataObj_CountUserDataType(_self, _args)
+ UserDataObject *_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;
- if (!PyArg_ParseTuple(_args, "lO&l",
- &time,
- ResObj_Convert, &sampleDescriptionH,
- &maxNumberOfSamples))
+ short _rv;
+ OSType udType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &udType))
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(_self, _args)
- MediaObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- OSErr _err;
- long maxChunkSize;
- 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(_self, _args)
- MediaObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- OSErr _err;
- long maxChunkSize;
- 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(_self, _args)
- MediaObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- OSErr _err;
- long frameDiffSampleNum;
- long syncSampleNum;
- 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(_self, _args)
- MediaObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- OSErr _err;
- long frameDiffSampleNum;
- long syncSampleNum;
- 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);
+ _rv = CountUserDataType(_self->ob_itself,
+ udType);
+ _res = Py_BuildValue("h",
+ _rv);
return _res;
}
-static PyObject *MediaObj_GetMediaDataSize(_self, _args)
- MediaObject *_self;
+static PyObject *UserDataObj_GetNextUserDataType(_self, _args)
+ UserDataObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
long _rv;
- TimeValue startTime;
- TimeValue duration;
- if (!PyArg_ParseTuple(_args, "ll",
- &startTime,
- &duration))
+ OSType udType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &udType))
return NULL;
- _rv = GetMediaDataSize(_self->ob_itself,
- startTime,
- duration);
+ _rv = GetNextUserDataType(_self->ob_itself,
+ udType);
_res = Py_BuildValue("l",
_rv);
return _res;
}
-static PyObject *MediaObj_GetMediaNextInterestingTime(_self, _args)
- MediaObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- short interestingTimeFlags;
- TimeValue time;
- Fixed rate;
- TimeValue interestingTime;
- TimeValue interestingDuration;
- 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(_self, _args)
- MediaObject *_self;
+static PyObject *UserDataObj_AddUserDataText(_self, _args)
+ UserDataObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- short index;
- Handle dataRef;
- OSType dataRefType;
- long dataRefAttributes;
- if (!PyArg_ParseTuple(_args, "h",
- &index))
+ Handle data;
+ OSType udType;
+ long index;
+ short itlRegionTag;
+ if (!PyArg_ParseTuple(_args, "O&O&lh",
+ ResObj_Convert, &data,
+ PyMac_GetOSType, &udType,
+ &index,
+ &itlRegionTag))
return NULL;
- _err = GetMediaDataRef(_self->ob_itself,
+ _err = AddUserDataText(_self->ob_itself,
+ data,
+ udType,
index,
- &dataRef,
- &dataRefType,
- &dataRefAttributes);
+ itlRegionTag);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("O&O&l",
- ResObj_New, dataRef,
- PyMac_BuildOSType, dataRefType,
- dataRefAttributes);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MediaObj_SetMediaDataRef(_self, _args)
- MediaObject *_self;
+static PyObject *UserDataObj_GetUserDataText(_self, _args)
+ UserDataObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- short index;
- Handle dataRef;
- OSType dataRefType;
- if (!PyArg_ParseTuple(_args, "hO&O&",
+ Handle data;
+ OSType udType;
+ long index;
+ short itlRegionTag;
+ if (!PyArg_ParseTuple(_args, "O&O&lh",
+ ResObj_Convert, &data,
+ PyMac_GetOSType, &udType,
&index,
- ResObj_Convert, &dataRef,
- PyMac_GetOSType, &dataRefType))
+ &itlRegionTag))
return NULL;
- _err = SetMediaDataRef(_self->ob_itself,
+ _err = GetUserDataText(_self->ob_itself,
+ data,
+ udType,
index,
- dataRef,
- dataRefType);
+ itlRegionTag);
if (_err != noErr) return PyMac_Error(_err);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MediaObj_SetMediaDataRefAttributes(_self, _args)
- MediaObject *_self;
+static PyObject *UserDataObj_RemoveUserDataText(_self, _args)
+ UserDataObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- short index;
- long dataRefAttributes;
- if (!PyArg_ParseTuple(_args, "hl",
+ OSType udType;
+ long index;
+ short itlRegionTag;
+ if (!PyArg_ParseTuple(_args, "O&lh",
+ PyMac_GetOSType, &udType,
&index,
- &dataRefAttributes))
+ &itlRegionTag))
return NULL;
- _err = SetMediaDataRefAttributes(_self->ob_itself,
- index,
- dataRefAttributes);
+ _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 *MediaObj_AddMediaDataRef(_self, _args)
- MediaObject *_self;
+static PyObject *UserDataObj_PutUserDataIntoHandle(_self, _args)
+ UserDataObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- short index;
- Handle dataRef;
- OSType dataRefType;
- if (!PyArg_ParseTuple(_args, "O&O&",
- ResObj_Convert, &dataRef,
- PyMac_GetOSType, &dataRefType))
+ Handle h;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &h))
return NULL;
- _err = AddMediaDataRef(_self->ob_itself,
- &index,
- dataRef,
- dataRefType);
+ _err = PutUserDataIntoHandle(_self->ob_itself,
+ h);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("h",
- index);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MediaObj_GetMediaDataRefCount(_self, _args)
- MediaObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- OSErr _err;
- short count;
- 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(_self, _args)
- MediaObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- long flags;
- long flagsMask;
- 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 PyMethodDef MediaObj_methods[] = {
- {"LoadMediaIntoRam", (PyCFunction)MediaObj_LoadMediaIntoRam, 1,
- "(TimeValue time, TimeValue duration, long flags) -> None"},
- {"GetMediaTrack", (PyCFunction)MediaObj_GetMediaTrack, 1,
- "() -> (Track _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)"},
- {"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)"},
- {"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"},
+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 MediaObj_chain = { MediaObj_methods, NULL };
+PyMethodChain UserDataObj_chain = { UserDataObj_methods, NULL };
-static PyObject *MediaObj_getattr(self, name)
- MediaObject *self;
+static PyObject *UserDataObj_getattr(self, name)
+ UserDataObject *self;
char *name;
{
- return Py_FindMethodInChain(&MediaObj_chain, (PyObject *)self, name);
+ return Py_FindMethodInChain(&UserDataObj_chain, (PyObject *)self, name);
}
-#define MediaObj_setattr NULL
+#define UserDataObj_setattr NULL
-PyTypeObject Media_Type = {
+PyTypeObject UserData_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
- "Media", /*tp_name*/
- sizeof(MediaObject), /*tp_basicsize*/
+ "UserData", /*tp_name*/
+ sizeof(UserDataObject), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
- (destructor) MediaObj_dealloc, /*tp_dealloc*/
+ (destructor) UserDataObj_dealloc, /*tp_dealloc*/
0, /*tp_print*/
- (getattrfunc) MediaObj_getattr, /*tp_getattr*/
- (setattrfunc) MediaObj_setattr, /*tp_setattr*/
+ (getattrfunc) UserDataObj_getattr, /*tp_getattr*/
+ (setattrfunc) UserDataObj_setattr, /*tp_setattr*/
};
-/* --------------------- End object type Media ---------------------- */
+/* -------------------- End object type UserData -------------------- */
-/* ----------------------- Object type Track ------------------------ */
+/* ----------------------- Object type Media ------------------------ */
-PyTypeObject Track_Type;
+PyTypeObject Media_Type;
-#define TrackObj_Check(x) ((x)->ob_type == &Track_Type)
+#define MediaObj_Check(x) ((x)->ob_type == &Media_Type)
-typedef struct TrackObject {
+typedef struct MediaObject {
PyObject_HEAD
- Track ob_itself;
-} TrackObject;
+ Media ob_itself;
+} MediaObject;
-PyObject *TrackObj_New(itself)
- Track itself;
+PyObject *MediaObj_New(itself)
+ Media itself;
{
- TrackObject *it;
+ MediaObject *it;
if (itself == NULL) {
- PyErr_SetString(Qt_Error,"Cannot create null Track");
+ PyErr_SetString(Qt_Error,"Cannot create null Media");
return NULL;
}
- it = PyObject_NEW(TrackObject, &Track_Type);
+ it = PyObject_NEW(MediaObject, &Media_Type);
if (it == NULL) return NULL;
it->ob_itself = itself;
return (PyObject *)it;
}
-TrackObj_Convert(v, p_itself)
+MediaObj_Convert(v, p_itself)
PyObject *v;
- Track *p_itself;
+ Media *p_itself;
{
- if (!TrackObj_Check(v))
+ if (!MediaObj_Check(v))
{
- PyErr_SetString(PyExc_TypeError, "Track required");
+ PyErr_SetString(PyExc_TypeError, "Media required");
return 0;
}
- *p_itself = ((TrackObject *)v)->ob_itself;
+ *p_itself = ((MediaObject *)v)->ob_itself;
return 1;
}
-static void TrackObj_dealloc(self)
- TrackObject *self;
+static void MediaObj_dealloc(self)
+ MediaObject *self;
{
- DisposeMovieTrack(self->ob_itself);
+ DisposeTrackMedia(self->ob_itself);
PyMem_DEL(self);
}
-static PyObject *TrackObj_LoadTrackIntoRam(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_LoadMediaIntoRam(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
&duration,
&flags))
return NULL;
- _err = LoadTrackIntoRam(_self->ob_itself,
+ _err = LoadMediaIntoRam(_self->ob_itself,
time,
duration,
flags);
return _res;
}
-static PyObject *TrackObj_GetTrackPict(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaTrack(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- PicHandle _rv;
- TimeValue time;
- if (!PyArg_ParseTuple(_args, "l",
- &time))
+ Track _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTrackPict(_self->ob_itself,
- time);
+ _rv = GetMediaTrack(_self->ob_itself);
_res = Py_BuildValue("O&",
- ResObj_New, _rv);
+ TrackObj_New, _rv);
return _res;
}
-static PyObject *TrackObj_GetTrackClipRgn(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaTimeScale(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle _rv;
+ TimeScale _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTrackClipRgn(_self->ob_itself);
- _res = Py_BuildValue("O&",
- ResObj_New, _rv);
+ _rv = GetMediaTimeScale(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *TrackObj_SetTrackClipRgn(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_SetMediaTimeScale(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle theClip;
- if (!PyArg_ParseTuple(_args, "O&",
- ResObj_Convert, &theClip))
+ TimeScale timeScale;
+ if (!PyArg_ParseTuple(_args, "l",
+ &timeScale))
return NULL;
- SetTrackClipRgn(_self->ob_itself,
- theClip);
+ SetMediaTimeScale(_self->ob_itself,
+ timeScale);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *TrackObj_GetTrackDisplayBoundsRgn(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaDuration(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle _rv;
+ TimeValue _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTrackDisplayBoundsRgn(_self->ob_itself);
- _res = Py_BuildValue("O&",
- ResObj_New, _rv);
+ _rv = GetMediaDuration(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *TrackObj_GetTrackMovieBoundsRgn(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaLanguage(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle _rv;
+ short _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTrackMovieBoundsRgn(_self->ob_itself);
- _res = Py_BuildValue("O&",
- ResObj_New, _rv);
+ _rv = GetMediaLanguage(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
return _res;
}
-static PyObject *TrackObj_GetTrackBoundsRgn(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_SetMediaLanguage(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ short language;
+ if (!PyArg_ParseTuple(_args, "h",
+ &language))
return NULL;
- _rv = GetTrackBoundsRgn(_self->ob_itself);
- _res = Py_BuildValue("O&",
- ResObj_New, _rv);
+ SetMediaLanguage(_self->ob_itself,
+ language);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *TrackObj_GetTrackMatte(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaQuality(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- PixMapHandle _rv;
+ short _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTrackMatte(_self->ob_itself);
- _res = Py_BuildValue("O&",
- ResObj_New, _rv);
+ _rv = GetMediaQuality(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
return _res;
}
-static PyObject *TrackObj_SetTrackMatte(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_SetMediaQuality(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- PixMapHandle theMatte;
- if (!PyArg_ParseTuple(_args, "O&",
- ResObj_Convert, &theMatte))
+ short quality;
+ if (!PyArg_ParseTuple(_args, "h",
+ &quality))
return NULL;
- SetTrackMatte(_self->ob_itself,
- theMatte);
+ SetMediaQuality(_self->ob_itself,
+ quality);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *TrackObj_GetTrackID(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaHandlerDescription(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ OSType mediaType;
+ Str255 creatorName;
+ OSType creatorManufacturer;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, creatorName))
return NULL;
- _rv = GetTrackID(_self->ob_itself);
- _res = Py_BuildValue("l",
- _rv);
+ GetMediaHandlerDescription(_self->ob_itself,
+ &mediaType,
+ creatorName,
+ &creatorManufacturer);
+ _res = Py_BuildValue("O&O&",
+ PyMac_BuildOSType, mediaType,
+ PyMac_BuildOSType, creatorManufacturer);
return _res;
}
-static PyObject *TrackObj_GetTrackMovie(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaUserData(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Movie _rv;
+ UserData _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTrackMovie(_self->ob_itself);
+ _rv = GetMediaUserData(_self->ob_itself);
_res = Py_BuildValue("O&",
- MovieObj_New, _rv);
+ UserDataObj_New, _rv);
return _res;
}
-static PyObject *TrackObj_GetTrackEnabled(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaHandler(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Boolean _rv;
+ MediaHandler _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTrackEnabled(_self->ob_itself);
- _res = Py_BuildValue("b",
- _rv);
+ _rv = GetMediaHandler(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CmpInstObj_New, _rv);
return _res;
}
-static PyObject *TrackObj_SetTrackEnabled(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_SetMediaHandler(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Boolean isEnabled;
- if (!PyArg_ParseTuple(_args, "b",
- &isEnabled))
+ OSErr _err;
+ MediaHandlerComponent mH;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpObj_Convert, &mH))
return NULL;
- SetTrackEnabled(_self->ob_itself,
- isEnabled);
+ _err = SetMediaHandler(_self->ob_itself,
+ mH);
+ if (_err != noErr) return PyMac_Error(_err);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *TrackObj_GetTrackUsage(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_BeginMediaEdits(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long _rv;
+ OSErr _err;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTrackUsage(_self->ob_itself);
- _res = Py_BuildValue("l",
- _rv);
- return _res;
-}
-
-static PyObject *TrackObj_SetTrackUsage(_self, _args)
- TrackObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- long usage;
- if (!PyArg_ParseTuple(_args, "l",
- &usage))
- return NULL;
- SetTrackUsage(_self->ob_itself,
- usage);
+ _err = BeginMediaEdits(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *TrackObj_GetTrackDuration(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_EndMediaEdits(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue _rv;
+ OSErr _err;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTrackDuration(_self->ob_itself);
- _res = Py_BuildValue("l",
- _rv);
+ _err = EndMediaEdits(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *TrackObj_GetTrackOffset(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_SetMediaDefaultDataRefIndex(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ OSErr _err;
+ short index;
+ if (!PyArg_ParseTuple(_args, "h",
+ &index))
return NULL;
- _rv = GetTrackOffset(_self->ob_itself);
- _res = Py_BuildValue("l",
- _rv);
+ _err = SetMediaDefaultDataRefIndex(_self->ob_itself,
+ index);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *TrackObj_SetTrackOffset(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaDataHandlerDescription(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue movieOffsetTime;
- if (!PyArg_ParseTuple(_args, "l",
- &movieOffsetTime))
+ short index;
+ OSType dhType;
+ Str255 creatorName;
+ OSType creatorManufacturer;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &index,
+ PyMac_GetStr255, creatorName))
return NULL;
- SetTrackOffset(_self->ob_itself,
- movieOffsetTime);
- Py_INCREF(Py_None);
- _res = Py_None;
+ GetMediaDataHandlerDescription(_self->ob_itself,
+ index,
+ &dhType,
+ creatorName,
+ &creatorManufacturer);
+ _res = Py_BuildValue("O&O&",
+ PyMac_BuildOSType, dhType,
+ PyMac_BuildOSType, creatorManufacturer);
return _res;
}
-static PyObject *TrackObj_GetTrackLayer(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaDataHandler(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ DataHandler _rv;
+ short index;
+ if (!PyArg_ParseTuple(_args, "h",
+ &index))
return NULL;
- _rv = GetTrackLayer(_self->ob_itself);
- _res = Py_BuildValue("h",
- _rv);
+ _rv = GetMediaDataHandler(_self->ob_itself,
+ index);
+ _res = Py_BuildValue("O&",
+ CmpInstObj_New, _rv);
return _res;
}
-static PyObject *TrackObj_SetTrackLayer(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_SetMediaDataHandler(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short layer;
- if (!PyArg_ParseTuple(_args, "h",
- &layer))
+ OSErr _err;
+ short index;
+ DataHandlerComponent dataHandler;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &index,
+ CmpObj_Convert, &dataHandler))
return NULL;
- SetTrackLayer(_self->ob_itself,
- layer);
+ _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 *TrackObj_GetTrackAlternate(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaSampleDescriptionCount(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Track _rv;
+ long _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTrackAlternate(_self->ob_itself);
- _res = Py_BuildValue("O&",
- TrackObj_New, _rv);
+ _rv = GetMediaSampleDescriptionCount(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *TrackObj_SetTrackAlternate(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaSampleDescription(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Track alternateT;
- if (!PyArg_ParseTuple(_args, "O&",
- TrackObj_Convert, &alternateT))
+ long index;
+ SampleDescriptionHandle descH;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &index,
+ ResObj_Convert, &descH))
return NULL;
- SetTrackAlternate(_self->ob_itself,
- alternateT);
+ GetMediaSampleDescription(_self->ob_itself,
+ index,
+ descH);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *TrackObj_GetTrackVolume(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_SetMediaSampleDescription(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short _rv;
- if (!PyArg_ParseTuple(_args, ""))
- return NULL;
- _rv = GetTrackVolume(_self->ob_itself);
- _res = Py_BuildValue("h",
- _rv);
- return _res;
-}
-
-static PyObject *TrackObj_SetTrackVolume(_self, _args)
- TrackObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- short volume;
- if (!PyArg_ParseTuple(_args, "h",
- &volume))
+ OSErr _err;
+ long index;
+ SampleDescriptionHandle descH;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &index,
+ ResObj_Convert, &descH))
return NULL;
- SetTrackVolume(_self->ob_itself,
- volume);
+ _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 *TrackObj_GetTrackDimensions(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaSampleCount(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Fixed width;
- Fixed height;
+ long _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- GetTrackDimensions(_self->ob_itself,
- &width,
- &height);
- _res = Py_BuildValue("O&O&",
- PyMac_BuildFixed, width,
- PyMac_BuildFixed, height);
+ _rv = GetMediaSampleCount(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *TrackObj_SetTrackDimensions(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_SampleNumToMediaTime(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Fixed width;
- Fixed height;
- if (!PyArg_ParseTuple(_args, "O&O&",
- PyMac_GetFixed, &width,
- PyMac_GetFixed, &height))
+ long logicalSampleNum;
+ TimeValue sampleTime;
+ TimeValue sampleDuration;
+ if (!PyArg_ParseTuple(_args, "l",
+ &logicalSampleNum))
return NULL;
- SetTrackDimensions(_self->ob_itself,
- width,
- height);
- Py_INCREF(Py_None);
- _res = Py_None;
+ SampleNumToMediaTime(_self->ob_itself,
+ logicalSampleNum,
+ &sampleTime,
+ &sampleDuration);
+ _res = Py_BuildValue("ll",
+ sampleTime,
+ sampleDuration);
return _res;
}
-static PyObject *TrackObj_GetTrackUserData(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_MediaTimeToSampleNum(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- UserData _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ TimeValue time;
+ long sampleNum;
+ TimeValue sampleTime;
+ TimeValue sampleDuration;
+ if (!PyArg_ParseTuple(_args, "l",
+ &time))
return NULL;
- _rv = GetTrackUserData(_self->ob_itself);
- _res = Py_BuildValue("O&",
- UserDataObj_New, _rv);
+ MediaTimeToSampleNum(_self->ob_itself,
+ time,
+ &sampleNum,
+ &sampleTime,
+ &sampleDuration);
+ _res = Py_BuildValue("lll",
+ sampleNum,
+ sampleTime,
+ sampleDuration);
return _res;
}
-static PyObject *TrackObj_NewTrackMedia(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_AddMediaSample(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Media _rv;
- OSType mediaType;
- TimeScale timeScale;
- Handle dataRef;
- OSType dataRefType;
- if (!PyArg_ParseTuple(_args, "O&lO&O&",
- PyMac_GetOSType, &mediaType,
- &timeScale,
- ResObj_Convert, &dataRef,
- PyMac_GetOSType, &dataRefType))
+ OSErr _err;
+ Handle dataIn;
+ long inOffset;
+ unsigned long size;
+ TimeValue durationPerSample;
+ SampleDescriptionHandle sampleDescriptionH;
+ long numberOfSamples;
+ short sampleFlags;
+ TimeValue sampleTime;
+ if (!PyArg_ParseTuple(_args, "O&lllO&lh",
+ ResObj_Convert, &dataIn,
+ &inOffset,
+ &size,
+ &durationPerSample,
+ ResObj_Convert, &sampleDescriptionH,
+ &numberOfSamples,
+ &sampleFlags))
return NULL;
- _rv = NewTrackMedia(_self->ob_itself,
- mediaType,
- timeScale,
- dataRef,
- dataRefType);
- _res = Py_BuildValue("O&",
- MediaObj_New, _rv);
+ _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 *TrackObj_GetTrackMedia(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_AddMediaSampleReference(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Media _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ OSErr _err;
+ long dataOffset;
+ unsigned long size;
+ TimeValue durationPerSample;
+ SampleDescriptionHandle sampleDescriptionH;
+ long numberOfSamples;
+ short sampleFlags;
+ TimeValue sampleTime;
+ if (!PyArg_ParseTuple(_args, "lllO&lh",
+ &dataOffset,
+ &size,
+ &durationPerSample,
+ ResObj_Convert, &sampleDescriptionH,
+ &numberOfSamples,
+ &sampleFlags))
return NULL;
- _rv = GetTrackMedia(_self->ob_itself);
- _res = Py_BuildValue("O&",
- MediaObj_New, _rv);
+ _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 *TrackObj_InsertMediaIntoTrack(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaSample(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- TimeValue trackStart;
- TimeValue mediaTime;
- TimeValue mediaDuration;
- Fixed mediaRate;
- if (!PyArg_ParseTuple(_args, "lllO&",
- &trackStart,
- &mediaTime,
- &mediaDuration,
- PyMac_GetFixed, &mediaRate))
+ Handle dataOut;
+ long maxSizeToGrow;
+ long size;
+ TimeValue time;
+ TimeValue sampleTime;
+ TimeValue durationPerSample;
+ SampleDescriptionHandle sampleDescriptionH;
+ long sampleDescriptionIndex;
+ long maxNumberOfSamples;
+ long numberOfSamples;
+ short sampleFlags;
+ if (!PyArg_ParseTuple(_args, "O&llO&l",
+ ResObj_Convert, &dataOut,
+ &maxSizeToGrow,
+ &time,
+ ResObj_Convert, &sampleDescriptionH,
+ &maxNumberOfSamples))
return NULL;
- _err = InsertMediaIntoTrack(_self->ob_itself,
- trackStart,
- mediaTime,
- mediaDuration,
- mediaRate);
+ _err = GetMediaSample(_self->ob_itself,
+ dataOut,
+ maxSizeToGrow,
+ &size,
+ time,
+ &sampleTime,
+ &durationPerSample,
+ sampleDescriptionH,
+ &sampleDescriptionIndex,
+ maxNumberOfSamples,
+ &numberOfSamples,
+ &sampleFlags);
if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _res = Py_BuildValue("lllllh",
+ size,
+ sampleTime,
+ durationPerSample,
+ sampleDescriptionIndex,
+ numberOfSamples,
+ sampleFlags);
return _res;
}
-static PyObject *TrackObj_InsertTrackSegment(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaSampleReference(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- Track dstTrack;
- TimeValue srcIn;
- TimeValue srcDuration;
- TimeValue dstIn;
- 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(_self, _args)
- TrackObject *_self;
+ long dataOffset;
+ long size;
+ TimeValue time;
+ TimeValue sampleTime;
+ TimeValue durationPerSample;
+ SampleDescriptionHandle sampleDescriptionH;
+ long sampleDescriptionIndex;
+ long maxNumberOfSamples;
+ long numberOfSamples;
+ short sampleFlags;
+ 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(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- TimeValue dstIn;
- TimeValue dstDuration;
- if (!PyArg_ParseTuple(_args, "ll",
- &dstIn,
- &dstDuration))
+ long maxChunkSize;
+ if (!PyArg_ParseTuple(_args, "l",
+ &maxChunkSize))
return NULL;
- _err = InsertEmptyTrackSegment(_self->ob_itself,
- dstIn,
- dstDuration);
+ _err = SetMediaPreferredChunkSize(_self->ob_itself,
+ maxChunkSize);
if (_err != noErr) return PyMac_Error(_err);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *TrackObj_DeleteTrackSegment(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaPreferredChunkSize(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- TimeValue startTime;
- TimeValue duration;
+ long maxChunkSize;
+ 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(_self, _args)
+ MediaObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long frameDiffSampleNum;
+ long syncSampleNum;
if (!PyArg_ParseTuple(_args, "ll",
- &startTime,
- &duration))
+ &frameDiffSampleNum,
+ &syncSampleNum))
return NULL;
- _err = DeleteTrackSegment(_self->ob_itself,
- startTime,
- duration);
+ _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 *TrackObj_ScaleTrackSegment(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaShadowSync(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- TimeValue startTime;
- TimeValue oldDuration;
- TimeValue newDuration;
- if (!PyArg_ParseTuple(_args, "lll",
- &startTime,
- &oldDuration,
- &newDuration))
+ long frameDiffSampleNum;
+ long syncSampleNum;
+ if (!PyArg_ParseTuple(_args, "l",
+ &frameDiffSampleNum))
return NULL;
- _err = ScaleTrackSegment(_self->ob_itself,
- startTime,
- oldDuration,
- newDuration);
+ _err = GetMediaShadowSync(_self->ob_itself,
+ frameDiffSampleNum,
+ &syncSampleNum);
if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _res = Py_BuildValue("l",
+ syncSampleNum);
return _res;
}
-static PyObject *TrackObj_IsScrapMovie(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaDataSize(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Component _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ long _rv;
+ TimeValue startTime;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
return NULL;
- _rv = IsScrapMovie(_self->ob_itself);
- _res = Py_BuildValue("O&",
- CmpObj_New, _rv);
+ _rv = GetMediaDataSize(_self->ob_itself,
+ startTime,
+ duration);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *TrackObj_CopyTrackSettings(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaNextInterestingTime(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- Track dstTrack;
- if (!PyArg_ParseTuple(_args, "O&",
- TrackObj_Convert, &dstTrack))
+ short interestingTimeFlags;
+ TimeValue time;
+ Fixed rate;
+ TimeValue interestingTime;
+ TimeValue interestingDuration;
+ if (!PyArg_ParseTuple(_args, "hlO&",
+ &interestingTimeFlags,
+ &time,
+ PyMac_GetFixed, &rate))
return NULL;
- _err = CopyTrackSettings(_self->ob_itself,
- dstTrack);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ GetMediaNextInterestingTime(_self->ob_itself,
+ interestingTimeFlags,
+ time,
+ rate,
+ &interestingTime,
+ &interestingDuration);
+ _res = Py_BuildValue("ll",
+ interestingTime,
+ interestingDuration);
return _res;
}
-static PyObject *TrackObj_AddEmptyTrackToMovie(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaDataRef(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- Movie dstMovie;
+ short index;
Handle dataRef;
OSType dataRefType;
- Track dstTrack;
- if (!PyArg_ParseTuple(_args, "O&O&O&",
- MovieObj_Convert, &dstMovie,
- ResObj_Convert, &dataRef,
- PyMac_GetOSType, &dataRefType))
+ long dataRefAttributes;
+ if (!PyArg_ParseTuple(_args, "h",
+ &index))
return NULL;
- _err = AddEmptyTrackToMovie(_self->ob_itself,
- dstMovie,
- dataRef,
- dataRefType,
- &dstTrack);
+ _err = GetMediaDataRef(_self->ob_itself,
+ index,
+ &dataRef,
+ &dataRefType,
+ &dataRefAttributes);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("O&",
- TrackObj_New, dstTrack);
+ _res = Py_BuildValue("O&O&l",
+ ResObj_New, dataRef,
+ PyMac_BuildOSType, dataRefType,
+ dataRefAttributes);
return _res;
}
-static PyObject *TrackObj_AddTrackReference(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_SetMediaDataRef(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- Track refTrack;
- OSType refType;
- long addedIndex;
- if (!PyArg_ParseTuple(_args, "O&O&",
- TrackObj_Convert, &refTrack,
- PyMac_GetOSType, &refType))
+ short index;
+ Handle dataRef;
+ OSType dataRefType;
+ if (!PyArg_ParseTuple(_args, "hO&O&",
+ &index,
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
return NULL;
- _err = AddTrackReference(_self->ob_itself,
- refTrack,
- refType,
- &addedIndex);
+ _err = SetMediaDataRef(_self->ob_itself,
+ index,
+ dataRef,
+ dataRefType);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("l",
- addedIndex);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *TrackObj_DeleteTrackReference(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_SetMediaDataRefAttributes(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- OSType refType;
- long index;
- if (!PyArg_ParseTuple(_args, "O&l",
- PyMac_GetOSType, &refType,
- &index))
+ short index;
+ long dataRefAttributes;
+ if (!PyArg_ParseTuple(_args, "hl",
+ &index,
+ &dataRefAttributes))
return NULL;
- _err = DeleteTrackReference(_self->ob_itself,
- refType,
- index);
+ _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 *TrackObj_SetTrackReference(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_AddMediaDataRef(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- Track refTrack;
- OSType refType;
- long index;
- if (!PyArg_ParseTuple(_args, "O&O&l",
- TrackObj_Convert, &refTrack,
- PyMac_GetOSType, &refType,
- &index))
+ short index;
+ Handle dataRef;
+ OSType dataRefType;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
return NULL;
- _err = SetTrackReference(_self->ob_itself,
- refTrack,
- refType,
- index);
+ _err = AddMediaDataRef(_self->ob_itself,
+ &index,
+ dataRef,
+ dataRefType);
if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _res = Py_BuildValue("h",
+ index);
return _res;
}
-static PyObject *TrackObj_GetTrackReference(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_GetMediaDataRefCount(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Track _rv;
- OSType refType;
- long index;
- if (!PyArg_ParseTuple(_args, "O&l",
- PyMac_GetOSType, &refType,
- &index))
+ OSErr _err;
+ short count;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTrackReference(_self->ob_itself,
- refType,
- index);
- _res = Py_BuildValue("O&",
- TrackObj_New, _rv);
+ _err = GetMediaDataRefCount(_self->ob_itself,
+ &count);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ count);
return _res;
}
-static PyObject *TrackObj_GetNextTrackReferenceType(_self, _args)
- TrackObject *_self;
+static PyObject *MediaObj_SetMediaPlayHints(_self, _args)
+ MediaObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSType _rv;
- OSType refType;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetOSType, &refType))
+ long flags;
+ long flagsMask;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &flags,
+ &flagsMask))
return NULL;
- _rv = GetNextTrackReferenceType(_self->ob_itself,
- refType);
- _res = Py_BuildValue("O&",
- PyMac_BuildOSType, _rv);
+ SetMediaPlayHints(_self->ob_itself,
+ flags,
+ flagsMask);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *TrackObj_GetTrackReferenceCount(_self, _args)
+static PyMethodDef MediaObj_methods[] = {
+ {"LoadMediaIntoRam", (PyCFunction)MediaObj_LoadMediaIntoRam, 1,
+ "(TimeValue time, TimeValue duration, long flags) -> None"},
+ {"GetMediaTrack", (PyCFunction)MediaObj_GetMediaTrack, 1,
+ "() -> (Track _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)"},
+ {"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)"},
+ {"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"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain MediaObj_chain = { MediaObj_methods, NULL };
+
+static PyObject *MediaObj_getattr(self, name)
+ MediaObject *self;
+ char *name;
+{
+ return Py_FindMethodInChain(&MediaObj_chain, (PyObject *)self, name);
+}
+
+#define MediaObj_setattr NULL
+
+PyTypeObject Media_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "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*/
+};
+
+/* --------------------- 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(itself)
+ 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;
+}
+TrackObj_Convert(v, p_itself)
+ 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(self)
+ TrackObject *self;
+{
+ DisposeMovieTrack(self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *TrackObj_LoadTrackIntoRam(_self, _args)
TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long _rv;
- OSType refType;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetOSType, &refType))
+ OSErr _err;
+ TimeValue time;
+ TimeValue duration;
+ long flags;
+ if (!PyArg_ParseTuple(_args, "lll",
+ &time,
+ &duration,
+ &flags))
return NULL;
- _rv = GetTrackReferenceCount(_self->ob_itself,
- refType);
- _res = Py_BuildValue("l",
- _rv);
+ _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_GetTrackEditRate(_self, _args)
+static PyObject *TrackObj_GetTrackPict(_self, _args)
TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Fixed _rv;
- TimeValue atTime;
+ PicHandle _rv;
+ TimeValue time;
if (!PyArg_ParseTuple(_args, "l",
- &atTime))
+ &time))
return NULL;
- _rv = GetTrackEditRate(_self->ob_itself,
- atTime);
+ _rv = GetTrackPict(_self->ob_itself,
+ time);
_res = Py_BuildValue("O&",
- PyMac_BuildFixed, _rv);
+ ResObj_New, _rv);
return _res;
}
-static PyObject *TrackObj_GetTrackDataSize(_self, _args)
+static PyObject *TrackObj_GetTrackClipRgn(_self, _args)
TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long _rv;
- TimeValue startTime;
- TimeValue duration;
- if (!PyArg_ParseTuple(_args, "ll",
- &startTime,
- &duration))
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTrackDataSize(_self->ob_itself,
- startTime,
- duration);
- _res = Py_BuildValue("l",
- _rv);
+ _rv = GetTrackClipRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
return _res;
}
-static PyObject *TrackObj_PtInTrack(_self, _args)
+static PyObject *TrackObj_SetTrackClipRgn(_self, _args)
TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Boolean _rv;
- Point pt;
+ RgnHandle theClip;
if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetPoint, &pt))
+ ResObj_Convert, &theClip))
return NULL;
- _rv = PtInTrack(_self->ob_itself,
- pt);
- _res = Py_BuildValue("b",
- _rv);
+ SetTrackClipRgn(_self->ob_itself,
+ theClip);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *TrackObj_GetTrackNextInterestingTime(_self, _args)
+static PyObject *TrackObj_GetTrackDisplayBoundsRgn(_self, _args)
TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short interestingTimeFlags;
- TimeValue time;
- Fixed rate;
- TimeValue interestingTime;
- TimeValue interestingDuration;
- if (!PyArg_ParseTuple(_args, "hlO&",
- &interestingTimeFlags,
- &time,
- PyMac_GetFixed, &rate))
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- GetTrackNextInterestingTime(_self->ob_itself,
- interestingTimeFlags,
- time,
- rate,
- &interestingTime,
- &interestingDuration);
- _res = Py_BuildValue("ll",
- interestingTime,
- interestingDuration);
+ _rv = GetTrackDisplayBoundsRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
return _res;
}
-static PyObject *TrackObj_GetTrackSegmentDisplayBoundsRgn(_self, _args)
+static PyObject *TrackObj_GetTrackMovieBoundsRgn(_self, _args)
TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
RgnHandle _rv;
- TimeValue time;
- TimeValue duration;
- if (!PyArg_ParseTuple(_args, "ll",
- &time,
- &duration))
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTrackSegmentDisplayBoundsRgn(_self->ob_itself,
- time,
- duration);
+ _rv = GetTrackMovieBoundsRgn(_self->ob_itself);
_res = Py_BuildValue("O&",
ResObj_New, _rv);
return _res;
}
-static PyObject *TrackObj_GetTrackStatus(_self, _args)
+static PyObject *TrackObj_GetTrackBoundsRgn(_self, _args)
TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
+ RgnHandle _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetTrackStatus(_self->ob_itself);
+ _rv = GetTrackBoundsRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackMatte(_self, _args)
+ TrackObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ PixMapHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackMatte(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_SetTrackMatte(_self, _args)
+ TrackObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ PixMapHandle theMatte;
+ 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(_self, _args)
+ TrackObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackID(_self->ob_itself);
_res = Py_BuildValue("l",
_rv);
return _res;
}
-static PyObject *TrackObj_SetTrackLoadSettings(_self, _args)
+static PyObject *TrackObj_GetTrackMovie(_self, _args)
TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue preloadTime;
- TimeValue preloadDuration;
- long preloadFlags;
- long defaultHints;
- if (!PyArg_ParseTuple(_args, "llll",
- &preloadTime,
- &preloadDuration,
- &preloadFlags,
- &defaultHints))
+ Movie _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SetTrackLoadSettings(_self->ob_itself,
- preloadTime,
- preloadDuration,
- preloadFlags,
- defaultHints);
+ _rv = GetTrackMovie(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackEnabled(_self, _args)
+ TrackObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackEnabled(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_SetTrackEnabled(_self, _args)
+ TrackObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean isEnabled;
+ 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_GetTrackLoadSettings(_self, _args)
+static PyObject *TrackObj_GetTrackUsage(_self, _args)
TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue preloadTime;
- TimeValue preloadDuration;
- long preloadFlags;
- long defaultHints;
+ long _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- GetTrackLoadSettings(_self->ob_itself,
- &preloadTime,
- &preloadDuration,
- &preloadFlags,
- &defaultHints);
- _res = Py_BuildValue("llll",
- preloadTime,
- preloadDuration,
- preloadFlags,
- defaultHints);
+ _rv = GetTrackUsage(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
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)"},
- {"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)"},
- {"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)"},
- {"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)"},
- {"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(self, name)
- TrackObject *self;
- char *name;
-{
- return Py_FindMethodInChain(&TrackObj_chain, (PyObject *)self, name);
-}
-
-#define TrackObj_setattr NULL
-
-PyTypeObject Track_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
- 0, /*ob_size*/
- "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*/
-};
-
-/* --------------------- 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(itself)
- 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;
-}
-MovieObj_Convert(v, p_itself)
- 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(self)
- MovieObject *self;
-{
- DisposeMovie(self->ob_itself);
- PyMem_DEL(self);
-}
-
-static PyObject *MovieObj_MoviesTask(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_SetTrackUsage(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long maxMilliSecToUse;
+ long usage;
if (!PyArg_ParseTuple(_args, "l",
- &maxMilliSecToUse))
+ &usage))
return NULL;
- MoviesTask(_self->ob_itself,
- maxMilliSecToUse);
+ SetTrackUsage(_self->ob_itself,
+ usage);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_PrerollMovie(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackDuration(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- TimeValue time;
- Fixed Rate;
- if (!PyArg_ParseTuple(_args, "lO&",
- &time,
- PyMac_GetFixed, &Rate))
+ TimeValue _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _err = PrerollMovie(_self->ob_itself,
- time,
- Rate);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetTrackDuration(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *MovieObj_LoadMovieIntoRam(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackOffset(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- TimeValue time;
- TimeValue duration;
- long flags;
- if (!PyArg_ParseTuple(_args, "lll",
- &time,
- &duration,
- &flags))
+ TimeValue _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _err = LoadMovieIntoRam(_self->ob_itself,
- time,
- duration,
- flags);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetTrackOffset(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *MovieObj_SetMovieActive(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_SetTrackOffset(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Boolean active;
- if (!PyArg_ParseTuple(_args, "b",
- &active))
+ TimeValue movieOffsetTime;
+ if (!PyArg_ParseTuple(_args, "l",
+ &movieOffsetTime))
return NULL;
- SetMovieActive(_self->ob_itself,
- active);
+ SetTrackOffset(_self->ob_itself,
+ movieOffsetTime);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_GetMovieActive(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackLayer(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Boolean _rv;
+ short _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMovieActive(_self->ob_itself);
- _res = Py_BuildValue("b",
+ _rv = GetTrackLayer(_self->ob_itself);
+ _res = Py_BuildValue("h",
_rv);
return _res;
}
-static PyObject *MovieObj_StartMovie(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_SetTrackLayer(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- if (!PyArg_ParseTuple(_args, ""))
+ short layer;
+ if (!PyArg_ParseTuple(_args, "h",
+ &layer))
return NULL;
- StartMovie(_self->ob_itself);
+ SetTrackLayer(_self->ob_itself,
+ layer);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_StopMovie(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackAlternate(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
+ Track _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- StopMovie(_self->ob_itself);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetTrackAlternate(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ TrackObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_GoToBeginningOfMovie(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_SetTrackAlternate(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- if (!PyArg_ParseTuple(_args, ""))
+ Track alternateT;
+ if (!PyArg_ParseTuple(_args, "O&",
+ TrackObj_Convert, &alternateT))
return NULL;
- GoToBeginningOfMovie(_self->ob_itself);
+ SetTrackAlternate(_self->ob_itself,
+ alternateT);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_GoToEndOfMovie(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackVolume(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
+ short _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- GoToEndOfMovie(_self->ob_itself);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetTrackVolume(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
return _res;
}
-static PyObject *MovieObj_IsMovieDone(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_SetTrackVolume(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Boolean _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ short volume;
+ if (!PyArg_ParseTuple(_args, "h",
+ &volume))
return NULL;
- _rv = IsMovieDone(_self->ob_itself);
- _res = Py_BuildValue("b",
- _rv);
+ SetTrackVolume(_self->ob_itself,
+ volume);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MovieObj_GetMoviePreviewMode(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackDimensions(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Boolean _rv;
+ Fixed width;
+ Fixed height;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMoviePreviewMode(_self->ob_itself);
- _res = Py_BuildValue("b",
- _rv);
- return _res;
-}
-
-static PyObject *MovieObj_SetMoviePreviewMode(_self, _args)
- MovieObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- Boolean usePreview;
- if (!PyArg_ParseTuple(_args, "b",
- &usePreview))
- return NULL;
- SetMoviePreviewMode(_self->ob_itself,
- usePreview);
- Py_INCREF(Py_None);
- _res = Py_None;
+ GetTrackDimensions(_self->ob_itself,
+ &width,
+ &height);
+ _res = Py_BuildValue("O&O&",
+ PyMac_BuildFixed, width,
+ PyMac_BuildFixed, height);
return _res;
}
-static PyObject *MovieObj_ShowMoviePoster(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_SetTrackDimensions(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- if (!PyArg_ParseTuple(_args, ""))
+ Fixed width;
+ Fixed height;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetFixed, &width,
+ PyMac_GetFixed, &height))
return NULL;
- ShowMoviePoster(_self->ob_itself);
+ SetTrackDimensions(_self->ob_itself,
+ width,
+ height);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_GetMovieTimeBase(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackUserData(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeBase _rv;
+ UserData _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMovieTimeBase(_self->ob_itself);
+ _rv = GetTrackUserData(_self->ob_itself);
_res = Py_BuildValue("O&",
- TimeBaseObj_New, _rv);
+ UserDataObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_GetNextTrackForCompositing(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_NewTrackMedia(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Track _rv;
- Track theTrack;
- if (!PyArg_ParseTuple(_args, "O&",
- TrackObj_Convert, &theTrack))
+ Media _rv;
+ OSType mediaType;
+ TimeScale timeScale;
+ Handle dataRef;
+ OSType dataRefType;
+ if (!PyArg_ParseTuple(_args, "O&lO&O&",
+ PyMac_GetOSType, &mediaType,
+ &timeScale,
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
return NULL;
- _rv = GetNextTrackForCompositing(_self->ob_itself,
- theTrack);
+ _rv = NewTrackMedia(_self->ob_itself,
+ mediaType,
+ timeScale,
+ dataRef,
+ dataRefType);
_res = Py_BuildValue("O&",
- TrackObj_New, _rv);
+ MediaObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_GetPrevTrackForCompositing(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackMedia(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Track _rv;
- Track theTrack;
- if (!PyArg_ParseTuple(_args, "O&",
- TrackObj_Convert, &theTrack))
+ Media _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetPrevTrackForCompositing(_self->ob_itself,
- theTrack);
+ _rv = GetTrackMedia(_self->ob_itself);
_res = Py_BuildValue("O&",
- TrackObj_New, _rv);
+ MediaObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_GetMoviePict(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_InsertMediaIntoTrack(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- PicHandle _rv;
- TimeValue time;
- if (!PyArg_ParseTuple(_args, "l",
- &time))
+ OSErr _err;
+ TimeValue trackStart;
+ TimeValue mediaTime;
+ TimeValue mediaDuration;
+ Fixed mediaRate;
+ if (!PyArg_ParseTuple(_args, "lllO&",
+ &trackStart,
+ &mediaTime,
+ &mediaDuration,
+ PyMac_GetFixed, &mediaRate))
return NULL;
- _rv = GetMoviePict(_self->ob_itself,
- time);
- _res = Py_BuildValue("O&",
- ResObj_New, _rv);
+ _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 *MovieObj_GetMoviePosterPict(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_InsertTrackSegment(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- PicHandle _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ OSErr _err;
+ Track dstTrack;
+ TimeValue srcIn;
+ TimeValue srcDuration;
+ TimeValue dstIn;
+ if (!PyArg_ParseTuple(_args, "O&lll",
+ TrackObj_Convert, &dstTrack,
+ &srcIn,
+ &srcDuration,
+ &dstIn))
return NULL;
- _rv = GetMoviePosterPict(_self->ob_itself);
- _res = Py_BuildValue("O&",
- ResObj_New, _rv);
+ _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 *MovieObj_UpdateMovie(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_InsertEmptyTrackSegment(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- if (!PyArg_ParseTuple(_args, ""))
+ TimeValue dstIn;
+ TimeValue dstDuration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &dstIn,
+ &dstDuration))
return NULL;
- _err = UpdateMovie(_self->ob_itself);
+ _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 *MovieObj_GetMovieBox(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_DeleteTrackSegment(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Rect boxRect;
- if (!PyArg_ParseTuple(_args, ""))
+ OSErr _err;
+ TimeValue startTime;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
return NULL;
- GetMovieBox(_self->ob_itself,
- &boxRect);
- _res = Py_BuildValue("O&",
- PyMac_BuildRect, &boxRect);
+ _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 *MovieObj_SetMovieBox(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_ScaleTrackSegment(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Rect boxRect;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetRect, &boxRect))
+ OSErr _err;
+ TimeValue startTime;
+ TimeValue oldDuration;
+ TimeValue newDuration;
+ if (!PyArg_ParseTuple(_args, "lll",
+ &startTime,
+ &oldDuration,
+ &newDuration))
return NULL;
- SetMovieBox(_self->ob_itself,
- &boxRect);
+ _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 *MovieObj_GetMovieDisplayClipRgn(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_IsScrapMovie(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle _rv;
+ Component _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMovieDisplayClipRgn(_self->ob_itself);
+ _rv = IsScrapMovie(_self->ob_itself);
_res = Py_BuildValue("O&",
- ResObj_New, _rv);
+ CmpObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_SetMovieDisplayClipRgn(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_CopyTrackSettings(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle theClip;
+ OSErr _err;
+ Track dstTrack;
if (!PyArg_ParseTuple(_args, "O&",
- ResObj_Convert, &theClip))
+ TrackObj_Convert, &dstTrack))
return NULL;
- SetMovieDisplayClipRgn(_self->ob_itself,
- theClip);
+ _err = CopyTrackSettings(_self->ob_itself,
+ dstTrack);
+ if (_err != noErr) return PyMac_Error(_err);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_GetMovieClipRgn(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_AddEmptyTrackToMovie(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ OSErr _err;
+ Movie dstMovie;
+ Handle dataRef;
+ OSType dataRefType;
+ Track dstTrack;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ MovieObj_Convert, &dstMovie,
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
return NULL;
- _rv = GetMovieClipRgn(_self->ob_itself);
- _res = Py_BuildValue("O&",
- ResObj_New, _rv);
- return _res;
-}
-
-static PyObject *MovieObj_SetMovieClipRgn(_self, _args)
- MovieObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- RgnHandle theClip;
- 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(_self, _args)
- MovieObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- RgnHandle _rv;
- if (!PyArg_ParseTuple(_args, ""))
- return NULL;
- _rv = GetMovieDisplayBoundsRgn(_self->ob_itself);
+ _err = AddEmptyTrackToMovie(_self->ob_itself,
+ dstMovie,
+ dataRef,
+ dataRefType,
+ &dstTrack);
+ if (_err != noErr) return PyMac_Error(_err);
_res = Py_BuildValue("O&",
- ResObj_New, _rv);
+ TrackObj_New, dstTrack);
return _res;
}
-static PyObject *MovieObj_GetMovieBoundsRgn(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_AddTrackReference(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ OSErr _err;
+ Track refTrack;
+ OSType refType;
+ long addedIndex;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ TrackObj_Convert, &refTrack,
+ PyMac_GetOSType, &refType))
return NULL;
- _rv = GetMovieBoundsRgn(_self->ob_itself);
- _res = Py_BuildValue("O&",
- ResObj_New, _rv);
+ _err = AddTrackReference(_self->ob_itself,
+ refTrack,
+ refType,
+ &addedIndex);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ addedIndex);
return _res;
}
-static PyObject *MovieObj_PutMovieIntoHandle(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_DeleteTrackReference(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- Handle publicMovie;
- if (!PyArg_ParseTuple(_args, "O&",
- ResObj_Convert, &publicMovie))
+ OSType refType;
+ long index;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetOSType, &refType,
+ &index))
return NULL;
- _err = PutMovieIntoHandle(_self->ob_itself,
- publicMovie);
+ _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 *MovieObj_PutMovieIntoDataFork(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_SetTrackReference(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- short fRefNum;
- long offset;
- long maxSize;
- if (!PyArg_ParseTuple(_args, "hll",
- &fRefNum,
- &offset,
- &maxSize))
+ Track refTrack;
+ OSType refType;
+ long index;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ TrackObj_Convert, &refTrack,
+ PyMac_GetOSType, &refType,
+ &index))
return NULL;
- _err = PutMovieIntoDataFork(_self->ob_itself,
- fRefNum,
- offset,
- maxSize);
+ _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 *MovieObj_GetMovieTimeScale(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackReference(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeScale _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ Track _rv;
+ OSType refType;
+ long index;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetOSType, &refType,
+ &index))
return NULL;
- _rv = GetMovieTimeScale(_self->ob_itself);
- _res = Py_BuildValue("l",
- _rv);
+ _rv = GetTrackReference(_self->ob_itself,
+ refType,
+ index);
+ _res = Py_BuildValue("O&",
+ TrackObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_SetMovieTimeScale(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetNextTrackReferenceType(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeScale timeScale;
- if (!PyArg_ParseTuple(_args, "l",
- &timeScale))
+ OSType _rv;
+ OSType refType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &refType))
return NULL;
- SetMovieTimeScale(_self->ob_itself,
- timeScale);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetNextTrackReferenceType(_self->ob_itself,
+ refType);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildOSType, _rv);
return _res;
}
-static PyObject *MovieObj_GetMovieDuration(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackReferenceCount(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ long _rv;
+ OSType refType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &refType))
return NULL;
- _rv = GetMovieDuration(_self->ob_itself);
+ _rv = GetTrackReferenceCount(_self->ob_itself,
+ refType);
_res = Py_BuildValue("l",
_rv);
return _res;
}
-static PyObject *MovieObj_GetMovieRate(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackEditRate(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
Fixed _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ TimeValue atTime;
+ if (!PyArg_ParseTuple(_args, "l",
+ &atTime))
return NULL;
- _rv = GetMovieRate(_self->ob_itself);
+ _rv = GetTrackEditRate(_self->ob_itself,
+ atTime);
_res = Py_BuildValue("O&",
PyMac_BuildFixed, _rv);
return _res;
}
-static PyObject *MovieObj_SetMovieRate(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackDataSize(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Fixed rate;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetFixed, &rate))
+ long _rv;
+ TimeValue startTime;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
return NULL;
- SetMovieRate(_self->ob_itself,
- rate);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetTrackDataSize(_self->ob_itself,
+ startTime,
+ duration);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *MovieObj_GetMoviePreferredRate(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_PtInTrack(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Fixed _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ Boolean _rv;
+ Point pt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &pt))
return NULL;
- _rv = GetMoviePreferredRate(_self->ob_itself);
- _res = Py_BuildValue("O&",
- PyMac_BuildFixed, _rv);
+ _rv = PtInTrack(_self->ob_itself,
+ pt);
+ _res = Py_BuildValue("b",
+ _rv);
return _res;
}
-static PyObject *MovieObj_SetMoviePreferredRate(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackNextInterestingTime(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
+ short interestingTimeFlags;
+ TimeValue time;
Fixed rate;
- if (!PyArg_ParseTuple(_args, "O&",
+ TimeValue interestingTime;
+ TimeValue interestingDuration;
+ if (!PyArg_ParseTuple(_args, "hlO&",
+ &interestingTimeFlags,
+ &time,
PyMac_GetFixed, &rate))
return NULL;
- SetMoviePreferredRate(_self->ob_itself,
- rate);
- Py_INCREF(Py_None);
- _res = Py_None;
+ GetTrackNextInterestingTime(_self->ob_itself,
+ interestingTimeFlags,
+ time,
+ rate,
+ &interestingTime,
+ &interestingDuration);
+ _res = Py_BuildValue("ll",
+ interestingTime,
+ interestingDuration);
return _res;
}
-static PyObject *MovieObj_GetMoviePreferredVolume(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackSegmentDisplayBoundsRgn(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ RgnHandle _rv;
+ TimeValue time;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &time,
+ &duration))
return NULL;
- _rv = GetMoviePreferredVolume(_self->ob_itself);
- _res = Py_BuildValue("h",
- _rv);
+ _rv = GetTrackSegmentDisplayBoundsRgn(_self->ob_itself,
+ time,
+ duration);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_SetMoviePreferredVolume(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackStatus(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short volume;
- if (!PyArg_ParseTuple(_args, "h",
- &volume))
+ ComponentResult _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SetMoviePreferredVolume(_self->ob_itself,
- volume);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetTrackStatus(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *MovieObj_GetMovieVolume(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_SetTrackLoadSettings(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ TimeValue preloadTime;
+ TimeValue preloadDuration;
+ long preloadFlags;
+ long defaultHints;
+ if (!PyArg_ParseTuple(_args, "llll",
+ &preloadTime,
+ &preloadDuration,
+ &preloadFlags,
+ &defaultHints))
return NULL;
- _rv = GetMovieVolume(_self->ob_itself);
- _res = Py_BuildValue("h",
- _rv);
+ SetTrackLoadSettings(_self->ob_itself,
+ preloadTime,
+ preloadDuration,
+ preloadFlags,
+ defaultHints);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MovieObj_SetMovieVolume(_self, _args)
- MovieObject *_self;
+static PyObject *TrackObj_GetTrackLoadSettings(_self, _args)
+ TrackObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short volume;
- if (!PyArg_ParseTuple(_args, "h",
- &volume))
+ TimeValue preloadTime;
+ TimeValue preloadDuration;
+ long preloadFlags;
+ long defaultHints;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SetMovieVolume(_self->ob_itself,
- volume);
- Py_INCREF(Py_None);
- _res = Py_None;
+ GetTrackLoadSettings(_self->ob_itself,
+ &preloadTime,
+ &preloadDuration,
+ &preloadFlags,
+ &defaultHints);
+ _res = Py_BuildValue("llll",
+ preloadTime,
+ preloadDuration,
+ preloadFlags,
+ defaultHints);
return _res;
}
-static PyObject *MovieObj_GetMoviePreviewTime(_self, _args)
+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)"},
+ {"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)"},
+ {"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)"},
+ {"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)"},
+ {"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(self, name)
+ TrackObject *self;
+ char *name;
+{
+ return Py_FindMethodInChain(&TrackObj_chain, (PyObject *)self, name);
+}
+
+#define TrackObj_setattr NULL
+
+PyTypeObject Track_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "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*/
+};
+
+/* --------------------- 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(itself)
+ 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;
+}
+MovieObj_Convert(v, p_itself)
+ 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(self)
+ MovieObject *self;
+{
+ DisposeMovie(self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *MovieObj_MoviesTask(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue previewTime;
- TimeValue previewDuration;
- if (!PyArg_ParseTuple(_args, ""))
+ long maxMilliSecToUse;
+ if (!PyArg_ParseTuple(_args, "l",
+ &maxMilliSecToUse))
return NULL;
- GetMoviePreviewTime(_self->ob_itself,
- &previewTime,
- &previewDuration);
- _res = Py_BuildValue("ll",
- previewTime,
- previewDuration);
+ MoviesTask(_self->ob_itself,
+ maxMilliSecToUse);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MovieObj_SetMoviePreviewTime(_self, _args)
+static PyObject *MovieObj_PrerollMovie(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue previewTime;
- TimeValue previewDuration;
- if (!PyArg_ParseTuple(_args, "ll",
- &previewTime,
- &previewDuration))
+ OSErr _err;
+ TimeValue time;
+ Fixed Rate;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &time,
+ PyMac_GetFixed, &Rate))
return NULL;
- SetMoviePreviewTime(_self->ob_itself,
- previewTime,
- previewDuration);
+ _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_GetMoviePosterTime(_self, _args)
+static PyObject *MovieObj_LoadMovieIntoRam(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ OSErr _err;
+ TimeValue time;
+ TimeValue duration;
+ long flags;
+ if (!PyArg_ParseTuple(_args, "lll",
+ &time,
+ &duration,
+ &flags))
return NULL;
- _rv = GetMoviePosterTime(_self->ob_itself);
- _res = Py_BuildValue("l",
- _rv);
+ _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_SetMoviePosterTime(_self, _args)
+static PyObject *MovieObj_SetMovieActive(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue posterTime;
- if (!PyArg_ParseTuple(_args, "l",
- &posterTime))
+ Boolean active;
+ if (!PyArg_ParseTuple(_args, "b",
+ &active))
return NULL;
- SetMoviePosterTime(_self->ob_itself,
- posterTime);
+ SetMovieActive(_self->ob_itself,
+ active);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_GetMovieSelection(_self, _args)
+static PyObject *MovieObj_GetMovieActive(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue selectionTime;
- TimeValue selectionDuration;
+ Boolean _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- GetMovieSelection(_self->ob_itself,
- &selectionTime,
- &selectionDuration);
- _res = Py_BuildValue("ll",
- selectionTime,
- selectionDuration);
+ _rv = GetMovieActive(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
return _res;
}
-static PyObject *MovieObj_SetMovieSelection(_self, _args)
+static PyObject *MovieObj_StartMovie(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue selectionTime;
- TimeValue selectionDuration;
- if (!PyArg_ParseTuple(_args, "ll",
- &selectionTime,
- &selectionDuration))
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SetMovieSelection(_self->ob_itself,
- selectionTime,
- selectionDuration);
+ StartMovie(_self->ob_itself);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_SetMovieActiveSegment(_self, _args)
+static PyObject *MovieObj_StopMovie(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue startTime;
- TimeValue duration;
- if (!PyArg_ParseTuple(_args, "ll",
- &startTime,
- &duration))
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SetMovieActiveSegment(_self->ob_itself,
- startTime,
- duration);
+ StopMovie(_self->ob_itself);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_GetMovieActiveSegment(_self, _args)
+static PyObject *MovieObj_GoToBeginningOfMovie(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue startTime;
- TimeValue duration;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- GetMovieActiveSegment(_self->ob_itself,
- &startTime,
- &duration);
- _res = Py_BuildValue("ll",
- startTime,
- duration);
+ GoToBeginningOfMovie(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MovieObj_SetMovieTimeValue(_self, _args)
+static PyObject *MovieObj_GoToEndOfMovie(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue newtime;
- if (!PyArg_ParseTuple(_args, "l",
- &newtime))
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SetMovieTimeValue(_self->ob_itself,
- newtime);
+ GoToEndOfMovie(_self->ob_itself);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_GetMovieUserData(_self, _args)
+static PyObject *MovieObj_IsMovieDone(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- UserData _rv;
+ Boolean _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMovieUserData(_self->ob_itself);
- _res = Py_BuildValue("O&",
- UserDataObj_New, _rv);
+ _rv = IsMovieDone(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
return _res;
}
-static PyObject *MovieObj_GetMovieTrackCount(_self, _args)
+static PyObject *MovieObj_GetMoviePreviewMode(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long _rv;
+ Boolean _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMovieTrackCount(_self->ob_itself);
- _res = Py_BuildValue("l",
+ _rv = GetMoviePreviewMode(_self->ob_itself);
+ _res = Py_BuildValue("b",
_rv);
return _res;
}
-static PyObject *MovieObj_GetMovieTrack(_self, _args)
+static PyObject *MovieObj_SetMoviePreviewMode(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Track _rv;
- long trackID;
- if (!PyArg_ParseTuple(_args, "l",
- &trackID))
+ Boolean usePreview;
+ if (!PyArg_ParseTuple(_args, "b",
+ &usePreview))
return NULL;
- _rv = GetMovieTrack(_self->ob_itself,
- trackID);
- _res = Py_BuildValue("O&",
- TrackObj_New, _rv);
+ SetMoviePreviewMode(_self->ob_itself,
+ usePreview);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MovieObj_GetMovieIndTrack(_self, _args)
+static PyObject *MovieObj_ShowMoviePoster(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Track _rv;
- long index;
- if (!PyArg_ParseTuple(_args, "l",
- &index))
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMovieIndTrack(_self->ob_itself,
- index);
+ ShowMoviePoster(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieTimeBase(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ TimeBase _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieTimeBase(_self->ob_itself);
_res = Py_BuildValue("O&",
- TrackObj_New, _rv);
+ TimeBaseObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_GetMovieIndTrackType(_self, _args)
+static PyObject *MovieObj_GetNextTrackForCompositing(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
Track _rv;
- long index;
- OSType trackType;
- long flags;
- if (!PyArg_ParseTuple(_args, "lO&l",
- &index,
- PyMac_GetOSType, &trackType,
- &flags))
+ Track theTrack;
+ if (!PyArg_ParseTuple(_args, "O&",
+ TrackObj_Convert, &theTrack))
return NULL;
- _rv = GetMovieIndTrackType(_self->ob_itself,
- index,
- trackType,
- flags);
+ _rv = GetNextTrackForCompositing(_self->ob_itself,
+ theTrack);
_res = Py_BuildValue("O&",
TrackObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_NewMovieTrack(_self, _args)
+static PyObject *MovieObj_GetPrevTrackForCompositing(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
Track _rv;
- Fixed width;
- Fixed height;
- short trackVolume;
- if (!PyArg_ParseTuple(_args, "O&O&h",
- PyMac_GetFixed, &width,
- PyMac_GetFixed, &height,
- &trackVolume))
+ Track theTrack;
+ if (!PyArg_ParseTuple(_args, "O&",
+ TrackObj_Convert, &theTrack))
return NULL;
- _rv = NewMovieTrack(_self->ob_itself,
- width,
- height,
- trackVolume);
+ _rv = GetPrevTrackForCompositing(_self->ob_itself,
+ theTrack);
_res = Py_BuildValue("O&",
TrackObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_SetAutoTrackAlternatesEnabled(_self, _args)
+static PyObject *MovieObj_GetMoviePict(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Boolean enable;
- if (!PyArg_ParseTuple(_args, "b",
- &enable))
+ PicHandle _rv;
+ TimeValue time;
+ if (!PyArg_ParseTuple(_args, "l",
+ &time))
return NULL;
- SetAutoTrackAlternatesEnabled(_self->ob_itself,
- enable);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetMoviePict(_self->ob_itself,
+ time);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_SelectMovieAlternates(_self, _args)
+static PyObject *MovieObj_GetMoviePosterPict(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
+ PicHandle _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SelectMovieAlternates(_self->ob_itself);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetMoviePosterPict(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_InsertMovieSegment(_self, _args)
+static PyObject *MovieObj_UpdateMovie(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- Movie dstMovie;
- TimeValue srcIn;
- TimeValue srcDuration;
- TimeValue dstIn;
- if (!PyArg_ParseTuple(_args, "O&lll",
- MovieObj_Convert, &dstMovie,
- &srcIn,
- &srcDuration,
- &dstIn))
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _err = InsertMovieSegment(_self->ob_itself,
- dstMovie,
- srcIn,
- srcDuration,
- dstIn);
+ _err = UpdateMovie(_self->ob_itself);
if (_err != noErr) return PyMac_Error(_err);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_InsertEmptyMovieSegment(_self, _args)
+static PyObject *MovieObj_GetMovieBox(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- TimeValue dstIn;
- TimeValue dstDuration;
- if (!PyArg_ParseTuple(_args, "ll",
- &dstIn,
- &dstDuration))
+ Rect boxRect;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _err = InsertEmptyMovieSegment(_self->ob_itself,
- dstIn,
- dstDuration);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ GetMovieBox(_self->ob_itself,
+ &boxRect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &boxRect);
return _res;
}
-static PyObject *MovieObj_DeleteMovieSegment(_self, _args)
+static PyObject *MovieObj_SetMovieBox(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- TimeValue startTime;
- TimeValue duration;
- if (!PyArg_ParseTuple(_args, "ll",
- &startTime,
- &duration))
+ Rect boxRect;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &boxRect))
return NULL;
- _err = DeleteMovieSegment(_self->ob_itself,
- startTime,
- duration);
- if (_err != noErr) return PyMac_Error(_err);
+ SetMovieBox(_self->ob_itself,
+ &boxRect);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_ScaleMovieSegment(_self, _args)
+static PyObject *MovieObj_GetMovieDisplayClipRgn(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- TimeValue startTime;
- TimeValue oldDuration;
- TimeValue newDuration;
- if (!PyArg_ParseTuple(_args, "lll",
- &startTime,
- &oldDuration,
- &newDuration))
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _err = ScaleMovieSegment(_self->ob_itself,
- startTime,
- oldDuration,
- newDuration);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetMovieDisplayClipRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_CutMovieSelection(_self, _args)
+static PyObject *MovieObj_SetMovieDisplayClipRgn(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Movie _rv;
- if (!PyArg_ParseTuple(_args, ""))
+ RgnHandle theClip;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theClip))
return NULL;
- _rv = CutMovieSelection(_self->ob_itself);
- _res = Py_BuildValue("O&",
- MovieObj_New, _rv);
+ SetMovieDisplayClipRgn(_self->ob_itself,
+ theClip);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MovieObj_CopyMovieSelection(_self, _args)
+static PyObject *MovieObj_GetMovieClipRgn(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Movie _rv;
+ RgnHandle _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = CopyMovieSelection(_self->ob_itself);
+ _rv = GetMovieClipRgn(_self->ob_itself);
_res = Py_BuildValue("O&",
- MovieObj_New, _rv);
+ ResObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_PasteMovieSelection(_self, _args)
+static PyObject *MovieObj_SetMovieClipRgn(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Movie src;
+ RgnHandle theClip;
if (!PyArg_ParseTuple(_args, "O&",
- MovieObj_Convert, &src))
+ ResObj_Convert, &theClip))
return NULL;
- PasteMovieSelection(_self->ob_itself,
- src);
+ SetMovieClipRgn(_self->ob_itself,
+ theClip);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_AddMovieSelection(_self, _args)
+static PyObject *MovieObj_GetMovieDisplayBoundsRgn(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Movie src;
- if (!PyArg_ParseTuple(_args, "O&",
- MovieObj_Convert, &src))
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- AddMovieSelection(_self->ob_itself,
- src);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetMovieDisplayBoundsRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_ClearMovieSelection(_self, _args)
+static PyObject *MovieObj_GetMovieBoundsRgn(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
+ RgnHandle _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- ClearMovieSelection(_self->ob_itself);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetMovieBoundsRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_PutMovieIntoTypedHandle(_self, _args)
+static PyObject *MovieObj_PutMovieIntoHandle(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- Track targetTrack;
- OSType handleType;
Handle publicMovie;
- TimeValue start;
- TimeValue dur;
- long flags;
- ComponentInstance userComp;
- if (!PyArg_ParseTuple(_args, "O&O&O&lllO&",
- TrackObj_Convert, &targetTrack,
- PyMac_GetOSType, &handleType,
- ResObj_Convert, &publicMovie,
- &start,
- &dur,
- &flags,
- CmpInstObj_Convert, &userComp))
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &publicMovie))
return NULL;
- _err = PutMovieIntoTypedHandle(_self->ob_itself,
- targetTrack,
- handleType,
- publicMovie,
- start,
- dur,
- flags,
- userComp);
+ _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_CopyMovieSettings(_self, _args)
+static PyObject *MovieObj_PutMovieIntoDataFork(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- Movie dstMovie;
- if (!PyArg_ParseTuple(_args, "O&",
- MovieObj_Convert, &dstMovie))
+ short fRefNum;
+ long offset;
+ long maxSize;
+ if (!PyArg_ParseTuple(_args, "hll",
+ &fRefNum,
+ &offset,
+ &maxSize))
return NULL;
- _err = CopyMovieSettings(_self->ob_itself,
- dstMovie);
+ _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_ConvertMovieToFile(_self, _args)
+static PyObject *MovieObj_GetMovieTimeScale(_self, _args)
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;
- 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))
+ TimeScale _rv;
+ if (!PyArg_ParseTuple(_args, ""))
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);
+ _rv = GetMovieTimeScale(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *MovieObj_GetMovieDataSize(_self, _args)
+static PyObject *MovieObj_SetMovieTimeScale(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long _rv;
- TimeValue startTime;
- TimeValue duration;
- if (!PyArg_ParseTuple(_args, "ll",
- &startTime,
- &duration))
+ TimeScale timeScale;
+ if (!PyArg_ParseTuple(_args, "l",
+ &timeScale))
return NULL;
- _rv = GetMovieDataSize(_self->ob_itself,
- startTime,
- duration);
- _res = Py_BuildValue("l",
- _rv);
+ SetMovieTimeScale(_self->ob_itself,
+ timeScale);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MovieObj_PtInMovie(_self, _args)
+static PyObject *MovieObj_GetMovieDuration(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Boolean _rv;
- Point pt;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetPoint, &pt))
+ TimeValue _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = PtInMovie(_self->ob_itself,
- pt);
- _res = Py_BuildValue("b",
+ _rv = GetMovieDuration(_self->ob_itself);
+ _res = Py_BuildValue("l",
_rv);
return _res;
}
-static PyObject *MovieObj_SetMovieLanguage(_self, _args)
+static PyObject *MovieObj_GetMovieRate(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long language;
- if (!PyArg_ParseTuple(_args, "l",
- &language))
+ Fixed _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SetMovieLanguage(_self->ob_itself,
- language);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = GetMovieRate(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildFixed, _rv);
return _res;
}
-static PyObject *MovieObj_GetMovieNextInterestingTime(_self, _args)
+static PyObject *MovieObj_SetMovieRate(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- short interestingTimeFlags;
- short numMediaTypes;
- OSType whichMediaTypes;
- TimeValue time;
Fixed rate;
- TimeValue interestingTime;
- TimeValue interestingDuration;
- if (!PyArg_ParseTuple(_args, "hhO&lO&",
- &interestingTimeFlags,
- &numMediaTypes,
- PyMac_GetOSType, &whichMediaTypes,
- &time,
+ if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetFixed, &rate))
return NULL;
- GetMovieNextInterestingTime(_self->ob_itself,
- interestingTimeFlags,
- numMediaTypes,
- &whichMediaTypes,
- time,
- rate,
- &interestingTime,
- &interestingDuration);
- _res = Py_BuildValue("ll",
- interestingTime,
- interestingDuration);
+ SetMovieRate(_self->ob_itself,
+ rate);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MovieObj_AddMovieResource(_self, _args)
+static PyObject *MovieObj_GetMoviePreferredRate(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- short resRefNum;
- short resId;
- Str255 resName;
- if (!PyArg_ParseTuple(_args, "hO&",
- &resRefNum,
- PyMac_GetStr255, resName))
+ Fixed _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _err = AddMovieResource(_self->ob_itself,
- resRefNum,
- &resId,
- resName);
- if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("h",
- resId);
+ _rv = GetMoviePreferredRate(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildFixed, _rv);
return _res;
}
-static PyObject *MovieObj_UpdateMovieResource(_self, _args)
+static PyObject *MovieObj_SetMoviePreferredRate(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- short resRefNum;
- short resId;
- Str255 resName;
- if (!PyArg_ParseTuple(_args, "hhO&",
- &resRefNum,
- &resId,
- PyMac_GetStr255, resName))
+ Fixed rate;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFixed, &rate))
return NULL;
- _err = UpdateMovieResource(_self->ob_itself,
- resRefNum,
- resId,
- resName);
- if (_err != noErr) return PyMac_Error(_err);
+ SetMoviePreferredRate(_self->ob_itself,
+ rate);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_HasMovieChanged(_self, _args)
+static PyObject *MovieObj_GetMoviePreferredVolume(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Boolean _rv;
+ short _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = HasMovieChanged(_self->ob_itself);
- _res = Py_BuildValue("b",
+ _rv = GetMoviePreferredVolume(_self->ob_itself);
+ _res = Py_BuildValue("h",
_rv);
return _res;
}
-static PyObject *MovieObj_ClearMovieChanged(_self, _args)
+static PyObject *MovieObj_SetMoviePreferredVolume(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- if (!PyArg_ParseTuple(_args, ""))
+ short volume;
+ if (!PyArg_ParseTuple(_args, "h",
+ &volume))
return NULL;
- ClearMovieChanged(_self->ob_itself);
+ SetMoviePreferredVolume(_self->ob_itself,
+ volume);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_SetMovieDefaultDataRef(_self, _args)
+static PyObject *MovieObj_GetMovieVolume(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- Handle dataRef;
- OSType dataRefType;
- if (!PyArg_ParseTuple(_args, "O&O&",
- ResObj_Convert, &dataRef,
- PyMac_GetOSType, &dataRefType))
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _err = SetMovieDefaultDataRef(_self->ob_itself,
- dataRef,
- dataRefType);
- if (_err != noErr) return PyMac_Error(_err);
+ _rv = GetMovieVolume(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieVolume(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short volume;
+ 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_GetMovieDefaultDataRef(_self, _args)
+static PyObject *MovieObj_GetMoviePreviewTime(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- Handle dataRef;
- OSType dataRefType;
+ TimeValue previewTime;
+ TimeValue previewDuration;
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);
+ GetMoviePreviewTime(_self->ob_itself,
+ &previewTime,
+ &previewDuration);
+ _res = Py_BuildValue("ll",
+ previewTime,
+ previewDuration);
return _res;
}
-static PyObject *MovieObj_SetMovieColorTable(_self, _args)
+static PyObject *MovieObj_SetMoviePreviewTime(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- CTabHandle ctab;
- if (!PyArg_ParseTuple(_args, "O&",
- ResObj_Convert, &ctab))
+ TimeValue previewTime;
+ TimeValue previewDuration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &previewTime,
+ &previewDuration))
return NULL;
- _err = SetMovieColorTable(_self->ob_itself,
- ctab);
- if (_err != noErr) return PyMac_Error(_err);
+ SetMoviePreviewTime(_self->ob_itself,
+ previewTime,
+ previewDuration);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *MovieObj_GetMovieColorTable(_self, _args)
+static PyObject *MovieObj_GetMoviePosterTime(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- CTabHandle ctab;
+ TimeValue _rv;
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);
+ _rv = GetMoviePosterTime(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *MovieObj_FlattenMovie(_self, _args)
+static PyObject *MovieObj_SetMoviePosterTime(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long movieFlattenFlags;
- FSSpec theFile;
- OSType creator;
- ScriptCode scriptTag;
- long createMovieFileFlags;
- short resId;
- Str255 resName;
- if (!PyArg_ParseTuple(_args, "lO&O&hlO&",
- &movieFlattenFlags,
- PyMac_GetFSSpec, &theFile,
- PyMac_GetOSType, &creator,
- &scriptTag,
- &createMovieFileFlags,
- PyMac_GetStr255, resName))
+ TimeValue posterTime;
+ if (!PyArg_ParseTuple(_args, "l",
+ &posterTime))
return NULL;
- FlattenMovie(_self->ob_itself,
- movieFlattenFlags,
- &theFile,
- creator,
- scriptTag,
- createMovieFileFlags,
- &resId,
- resName);
- _res = Py_BuildValue("h",
- resId);
+ SetMoviePosterTime(_self->ob_itself,
+ posterTime);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MovieObj_FlattenMovieData(_self, _args)
+static PyObject *MovieObj_GetMovieSelection(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Movie _rv;
- long movieFlattenFlags;
- FSSpec theFile;
- OSType creator;
- ScriptCode scriptTag;
- long createMovieFileFlags;
- if (!PyArg_ParseTuple(_args, "lO&O&hl",
- &movieFlattenFlags,
- PyMac_GetFSSpec, &theFile,
- PyMac_GetOSType, &creator,
- &scriptTag,
- &createMovieFileFlags))
+ TimeValue selectionTime;
+ TimeValue selectionDuration;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = FlattenMovieData(_self->ob_itself,
- movieFlattenFlags,
- &theFile,
- creator,
- scriptTag,
- createMovieFileFlags);
- _res = Py_BuildValue("O&",
- MovieObj_New, _rv);
+ GetMovieSelection(_self->ob_itself,
+ &selectionTime,
+ &selectionDuration);
+ _res = Py_BuildValue("ll",
+ selectionTime,
+ selectionDuration);
return _res;
}
-static PyObject *MovieObj_MovieSearchText(_self, _args)
+static PyObject *MovieObj_SetMovieSelection(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- Ptr text;
- long size;
- long searchFlags;
- Track searchTrack;
- TimeValue searchTime;
- long searchOffset;
- if (!PyArg_ParseTuple(_args, "sll",
- &text,
- &size,
- &searchFlags))
+ TimeValue selectionTime;
+ TimeValue selectionDuration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &selectionTime,
+ &selectionDuration))
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);
+ SetMovieSelection(_self->ob_itself,
+ selectionTime,
+ selectionDuration);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *MovieObj_GetPosterBox(_self, _args)
+static PyObject *MovieObj_SetMovieActiveSegment(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Rect boxRect;
- if (!PyArg_ParseTuple(_args, ""))
- return NULL;
- GetPosterBox(_self->ob_itself,
- &boxRect);
- _res = Py_BuildValue("O&",
- PyMac_BuildRect, &boxRect);
+ TimeValue startTime;
+ TimeValue duration;
+ 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_SetPosterBox(_self, _args)
+static PyObject *MovieObj_GetMovieActiveSegment(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Rect boxRect;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetRect, &boxRect))
+ TimeValue startTime;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- SetPosterBox(_self->ob_itself,
- &boxRect);
+ GetMovieActiveSegment(_self->ob_itself,
+ &startTime,
+ &duration);
+ _res = Py_BuildValue("ll",
+ startTime,
+ duration);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieTimeValue(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ TimeValue newtime;
+ 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_GetMovieSegmentDisplayBoundsRgn(_self, _args)
+static PyObject *MovieObj_GetMovieUserData(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle _rv;
- TimeValue time;
- TimeValue duration;
- if (!PyArg_ParseTuple(_args, "ll",
- &time,
- &duration))
+ UserData _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMovieSegmentDisplayBoundsRgn(_self->ob_itself,
- time,
- duration);
+ _rv = GetMovieUserData(_self->ob_itself);
_res = Py_BuildValue("O&",
- ResObj_New, _rv);
+ UserDataObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_GetMovieStatus(_self, _args)
+static PyObject *MovieObj_GetMovieTrackCount(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- Track firstProblemTrack;
+ long _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetMovieStatus(_self->ob_itself,
- &firstProblemTrack);
- _res = Py_BuildValue("lO&",
- _rv,
- TrackObj_New, firstProblemTrack);
+ _rv = GetMovieTrackCount(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *MovieObj_NewMovieController(_self, _args)
+static PyObject *MovieObj_GetMovieTrack(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentInstance _rv;
- Rect movieRect;
- long someFlags;
- if (!PyArg_ParseTuple(_args, "O&l",
- PyMac_GetRect, &movieRect,
- &someFlags))
+ Track _rv;
+ long trackID;
+ if (!PyArg_ParseTuple(_args, "l",
+ &trackID))
return NULL;
- _rv = NewMovieController(_self->ob_itself,
- &movieRect,
- someFlags);
+ _rv = GetMovieTrack(_self->ob_itself,
+ trackID);
_res = Py_BuildValue("O&",
- CmpInstObj_New, _rv);
+ TrackObj_New, _rv);
return _res;
}
-static PyObject *MovieObj_PutMovieOnScrap(_self, _args)
+static PyObject *MovieObj_GetMovieIndTrack(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- long movieScrapFlags;
+ Track _rv;
+ long index;
if (!PyArg_ParseTuple(_args, "l",
- &movieScrapFlags))
+ &index))
return NULL;
- _err = PutMovieOnScrap(_self->ob_itself,
- movieScrapFlags);
+ _rv = GetMovieIndTrack(_self->ob_itself,
+ index);
+ _res = Py_BuildValue("O&",
+ TrackObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieIndTrackType(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Track _rv;
+ long index;
+ OSType trackType;
+ long flags;
+ 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(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Track _rv;
+ Fixed width;
+ Fixed height;
+ short trackVolume;
+ 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(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean enable;
+ 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(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ SelectMovieAlternates(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_InsertMovieSegment(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Movie dstMovie;
+ TimeValue srcIn;
+ TimeValue srcDuration;
+ TimeValue dstIn;
+ 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_SetMoviePlayHints(_self, _args)
+static PyObject *MovieObj_InsertEmptyMovieSegment(_self, _args)
MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long flags;
- long flagsMask;
+ OSErr _err;
+ TimeValue dstIn;
+ TimeValue dstDuration;
if (!PyArg_ParseTuple(_args, "ll",
- &flags,
- &flagsMask))
+ &dstIn,
+ &dstDuration))
return NULL;
- SetMoviePlayHints(_self->ob_itself,
- flags,
- flagsMask);
+ _err = InsertEmptyMovieSegment(_self->ob_itself,
+ dstIn,
+ dstDuration);
+ if (_err != noErr) return PyMac_Error(_err);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyMethodDef MovieObj_methods[] = {
- {"MoviesTask", (PyCFunction)MovieObj_MoviesTask, 1,
- "(long maxMilliSecToUse) -> None"},
- {"PrerollMovie", (PyCFunction)MovieObj_PrerollMovie, 1,
- "(TimeValue time, Fixed Rate) -> 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)"},
- {"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"},
- {"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)"},
- {"PutMovieIntoHandle", (PyCFunction)MovieObj_PutMovieIntoHandle, 1,
- "(Handle publicMovie) -> None"},
- {"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1,
- "(short fRefNum, long offset, long maxSize) -> None"},
- {"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)"},
- {"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)"},
- {"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)"},
- {"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)"},
- {"NewMovieController", (PyCFunction)MovieObj_NewMovieController, 1,
- "(Rect movieRect, long someFlags) -> (ComponentInstance _rv)"},
- {"PutMovieOnScrap", (PyCFunction)MovieObj_PutMovieOnScrap, 1,
- "(long movieScrapFlags) -> None"},
- {"SetMoviePlayHints", (PyCFunction)MovieObj_SetMoviePlayHints, 1,
- "(long flags, long flagsMask) -> None"},
- {NULL, NULL, 0}
-};
-
-PyMethodChain MovieObj_chain = { MovieObj_methods, NULL };
-
-static PyObject *MovieObj_getattr(self, name)
- MovieObject *self;
- char *name;
-{
- return Py_FindMethodInChain(&MovieObj_chain, (PyObject *)self, name);
-}
-
-#define MovieObj_setattr NULL
-
-PyTypeObject Movie_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
- 0, /*ob_size*/
- "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*/
-};
-
-/* --------------------- End object type Movie ---------------------- */
-
-
-static PyObject *Qt_EnterMovies(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_DeleteMovieSegment(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- if (!PyArg_ParseTuple(_args, ""))
+ TimeValue startTime;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
return NULL;
- _err = EnterMovies();
+ _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 *Qt_ExitMovies(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_ScaleMovieSegment(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- if (!PyArg_ParseTuple(_args, ""))
+ OSErr _err;
+ TimeValue startTime;
+ TimeValue oldDuration;
+ TimeValue newDuration;
+ if (!PyArg_ParseTuple(_args, "lll",
+ &startTime,
+ &oldDuration,
+ &newDuration))
return NULL;
- ExitMovies();
+ _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 *Qt_GetMoviesError(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_CutMovieSelection(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
+ Movie _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _err = GetMoviesError();
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = CutMovieSelection(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
return _res;
}
-static PyObject *Qt_ClearMoviesStickyError(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_CopyMovieSelection(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
+ Movie _rv;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- ClearMoviesStickyError();
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = CopyMovieSelection(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
return _res;
}
-static PyObject *Qt_GetMoviesStickyError(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_PasteMovieSelection(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- if (!PyArg_ParseTuple(_args, ""))
+ Movie src;
+ if (!PyArg_ParseTuple(_args, "O&",
+ MovieObj_Convert, &src))
return NULL;
- _err = GetMoviesStickyError();
- if (_err != noErr) return PyMac_Error(_err);
+ PasteMovieSelection(_self->ob_itself,
+ src);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *Qt_DisposeMatte(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_AddMovieSelection(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- PixMapHandle theMatte;
+ Movie src;
if (!PyArg_ParseTuple(_args, "O&",
- ResObj_Convert, &theMatte))
+ MovieObj_Convert, &src))
return NULL;
- DisposeMatte(theMatte);
+ AddMovieSelection(_self->ob_itself,
+ src);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *Qt_NewMovie(_self, _args)
- PyObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- Movie _rv;
- long flags;
- if (!PyArg_ParseTuple(_args, "l",
- &flags))
- return NULL;
- _rv = NewMovie(flags);
- _res = Py_BuildValue("O&",
- MovieObj_New, _rv);
- return _res;
-}
-
-static PyObject *Qt_GetDataHandler(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_ClearMovieSelection(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Component _rv;
- Handle dataRef;
- OSType dataHandlerSubType;
- long flags;
- if (!PyArg_ParseTuple(_args, "O&O&l",
- ResObj_Convert, &dataRef,
- PyMac_GetOSType, &dataHandlerSubType,
- &flags))
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetDataHandler(dataRef,
- dataHandlerSubType,
- flags);
- _res = Py_BuildValue("O&",
- CmpObj_New, _rv);
+ ClearMovieSelection(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_PasteHandleIntoMovie(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_PutMovieIntoTypedHandle(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- Handle h;
+ Track targetTrack;
OSType handleType;
- Movie theMovie;
+ Handle publicMovie;
+ TimeValue start;
+ TimeValue dur;
long flags;
ComponentInstance userComp;
- if (!PyArg_ParseTuple(_args, "O&O&O&lO&",
- ResObj_Convert, &h,
+ if (!PyArg_ParseTuple(_args, "O&O&O&lllO&",
+ TrackObj_Convert, &targetTrack,
PyMac_GetOSType, &handleType,
- MovieObj_Convert, &theMovie,
+ ResObj_Convert, &publicMovie,
+ &start,
+ &dur,
&flags,
CmpInstObj_Convert, &userComp))
return NULL;
- _err = PasteHandleIntoMovie(h,
- handleType,
- theMovie,
- flags,
- userComp);
+ _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 *Qt_TrackTimeToMediaTime(_self, _args)
- PyObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- TimeValue _rv;
- TimeValue value;
- Track theTrack;
- 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(_self, _args)
- PyObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- OSErr _err;
- UserData theUserData;
- 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(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_CopyMovieSettings(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- Handle h;
- UserData theUserData;
+ Movie dstMovie;
if (!PyArg_ParseTuple(_args, "O&",
- ResObj_Convert, &h))
+ MovieObj_Convert, &dstMovie))
return NULL;
- _err = NewUserDataFromHandle(h,
- &theUserData);
+ _err = CopyMovieSettings(_self->ob_itself,
+ dstMovie);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("O&",
- UserDataObj_New, theUserData);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_CreateMovieFile(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_ConvertMovieToFile(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- FSSpec fileSpec;
+ Track onlyTrack;
+ FSSpec outputFile;
+ OSType fileType;
OSType creator;
ScriptCode scriptTag;
- long createMovieFileFlags;
- short resRefNum;
- Movie newmovie;
- if (!PyArg_ParseTuple(_args, "O&O&hl",
- PyMac_GetFSSpec, &fileSpec,
+ short resID;
+ long flags;
+ ComponentInstance userComp;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&hlO&",
+ TrackObj_Convert, &onlyTrack,
+ PyMac_GetFSSpec, &outputFile,
+ PyMac_GetOSType, &fileType,
PyMac_GetOSType, &creator,
&scriptTag,
- &createMovieFileFlags))
+ &flags,
+ CmpInstObj_Convert, &userComp))
return NULL;
- _err = CreateMovieFile(&fileSpec,
- creator,
- scriptTag,
- createMovieFileFlags,
- &resRefNum,
- &newmovie);
+ _err = ConvertMovieToFile(_self->ob_itself,
+ onlyTrack,
+ &outputFile,
+ fileType,
+ creator,
+ scriptTag,
+ &resID,
+ flags,
+ userComp);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("hO&",
- resRefNum,
- MovieObj_New, newmovie);
+ _res = Py_BuildValue("h",
+ resID);
return _res;
}
-static PyObject *Qt_OpenMovieFile(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_GetMovieDataSize(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- FSSpec fileSpec;
- short resRefNum;
- SInt8 permission;
- if (!PyArg_ParseTuple(_args, "O&b",
- PyMac_GetFSSpec, &fileSpec,
- &permission))
+ long _rv;
+ TimeValue startTime;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
return NULL;
- _err = OpenMovieFile(&fileSpec,
- &resRefNum,
- permission);
- if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("h",
- resRefNum);
+ _rv = GetMovieDataSize(_self->ob_itself,
+ startTime,
+ duration);
+ _res = Py_BuildValue("l",
+ _rv);
return _res;
}
-static PyObject *Qt_CloseMovieFile(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_PtInMovie(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- short resRefNum;
- if (!PyArg_ParseTuple(_args, "h",
- &resRefNum))
+ Boolean _rv;
+ Point pt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &pt))
return NULL;
- _err = CloseMovieFile(resRefNum);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _rv = PtInMovie(_self->ob_itself,
+ pt);
+ _res = Py_BuildValue("b",
+ _rv);
return _res;
}
-static PyObject *Qt_DeleteMovieFile(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_SetMovieLanguage(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- FSSpec fileSpec;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetFSSpec, &fileSpec))
+ long language;
+ if (!PyArg_ParseTuple(_args, "l",
+ &language))
return NULL;
- _err = DeleteMovieFile(&fileSpec);
- if (_err != noErr) return PyMac_Error(_err);
+ SetMovieLanguage(_self->ob_itself,
+ language);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *Qt_NewMovieFromFile(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_GetMovieNextInterestingTime(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- OSErr _err;
- Movie theMovie;
- short resRefNum;
- short resId;
- StringPtr resName;
- short newMovieFlags;
- Boolean dataRefWasChanged;
- if (!PyArg_ParseTuple(_args, "hsh",
- &resRefNum,
- &resName,
- &newMovieFlags))
+ short interestingTimeFlags;
+ short numMediaTypes;
+ OSType whichMediaTypes;
+ TimeValue time;
+ Fixed rate;
+ TimeValue interestingTime;
+ TimeValue interestingDuration;
+ if (!PyArg_ParseTuple(_args, "hhO&lO&",
+ &interestingTimeFlags,
+ &numMediaTypes,
+ PyMac_GetOSType, &whichMediaTypes,
+ &time,
+ PyMac_GetFixed, &rate))
return NULL;
- _err = NewMovieFromFile(&theMovie,
- resRefNum,
- &resId,
- resName,
- 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(_self, _args)
- PyObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- OSErr _err;
- Movie theMovie;
- Handle h;
- short newMovieFlags;
- Boolean dataRefWasChanged;
- 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);
+ GetMovieNextInterestingTime(_self->ob_itself,
+ interestingTimeFlags,
+ numMediaTypes,
+ &whichMediaTypes,
+ time,
+ rate,
+ &interestingTime,
+ &interestingDuration);
+ _res = Py_BuildValue("ll",
+ interestingTime,
+ interestingDuration);
return _res;
}
-static PyObject *Qt_NewMovieFromDataFork(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_AddMovieResource(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
- Movie theMovie;
- short fRefNum;
- long fileOffset;
- short newMovieFlags;
- Boolean dataRefWasChanged;
- if (!PyArg_ParseTuple(_args, "hlh",
- &fRefNum,
- &fileOffset,
- &newMovieFlags))
+ short resRefNum;
+ short resId;
+ Str255 resName;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &resRefNum,
+ PyMac_GetStr255, resName))
return NULL;
- _err = NewMovieFromDataFork(&theMovie,
- fRefNum,
- fileOffset,
- newMovieFlags,
- &dataRefWasChanged);
+ _err = AddMovieResource(_self->ob_itself,
+ resRefNum,
+ &resId,
+ resName);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("O&b",
- MovieObj_New, theMovie,
- dataRefWasChanged);
+ _res = Py_BuildValue("h",
+ resId);
return _res;
}
-static PyObject *Qt_RemoveMovieResource(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_UpdateMovieResource(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
OSErr _err;
short resRefNum;
short resId;
- if (!PyArg_ParseTuple(_args, "hh",
+ Str255 resName;
+ if (!PyArg_ParseTuple(_args, "hhO&",
&resRefNum,
- &resId))
+ &resId,
+ PyMac_GetStr255, resName))
return NULL;
- _err = RemoveMovieResource(resRefNum,
- resId);
+ _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 *Qt_GetVideoMediaGraphicsMode(_self, _args)
- PyObject *_self;
- PyObject *_args;
-{
- PyObject *_res = NULL;
- HandlerError _rv;
- MediaHandler mh;
- long graphicsMode;
- RGBColor opColor;
- if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mh))
- return NULL;
- _rv = GetVideoMediaGraphicsMode(mh,
- &graphicsMode,
- &opColor);
- _res = Py_BuildValue("llO&",
- _rv,
- graphicsMode,
- QdRGB_New, &opColor);
- return _res;
-}
-
-static PyObject *Qt_SetVideoMediaGraphicsMode(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_HasMovieChanged(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- HandlerError _rv;
- MediaHandler mh;
- long graphicsMode;
- RGBColor opColor;
- if (!PyArg_ParseTuple(_args, "O&lO&",
- CmpInstObj_Convert, &mh,
- &graphicsMode,
- QdRGB_Convert, &opColor))
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = SetVideoMediaGraphicsMode(mh,
- graphicsMode,
- &opColor);
- _res = Py_BuildValue("l",
+ _rv = HasMovieChanged(_self->ob_itself);
+ _res = Py_BuildValue("b",
_rv);
return _res;
}
-static PyObject *Qt_GetSoundMediaBalance(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_ClearMovieChanged(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- HandlerError _rv;
- MediaHandler mh;
- short balance;
- if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mh))
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = GetSoundMediaBalance(mh,
- &balance);
- _res = Py_BuildValue("lh",
- _rv,
- balance);
+ ClearMovieChanged(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_SetSoundMediaBalance(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_SetMovieDefaultDataRef(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- HandlerError _rv;
- MediaHandler mh;
- short balance;
- if (!PyArg_ParseTuple(_args, "O&h",
- CmpInstObj_Convert, &mh,
- &balance))
+ OSErr _err;
+ Handle dataRef;
+ OSType dataRefType;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
return NULL;
- _rv = SetSoundMediaBalance(mh,
- balance);
- _res = Py_BuildValue("l",
- _rv);
+ _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 *Qt_FindNextText(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_GetMovieDefaultDataRef(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MediaHandler mh;
- Ptr text;
- long size;
- short findFlags;
- TimeValue startTime;
- TimeValue foundTime;
- TimeValue foundDuration;
- long offset;
- if (!PyArg_ParseTuple(_args, "O&slhl",
- CmpInstObj_Convert, &mh,
- &text,
- &size,
- &findFlags,
- &startTime))
+ OSErr _err;
+ Handle dataRef;
+ OSType dataRefType;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = FindNextText(mh,
- text,
- size,
- findFlags,
- startTime,
- &foundTime,
- &foundDuration,
- &offset);
- _res = Py_BuildValue("llll",
- _rv,
- foundTime,
- foundDuration,
- offset);
+ _err = GetMovieDefaultDataRef(_self->ob_itself,
+ &dataRef,
+ &dataRefType);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&",
+ ResObj_New, dataRef,
+ PyMac_BuildOSType, dataRefType);
return _res;
}
-static PyObject *Qt_DisposeMovieController(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_SetMovieColorTable(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentInstance mc;
+ OSErr _err;
+ CTabHandle ctab;
if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ ResObj_Convert, &ctab))
return NULL;
- DisposeMovieController(mc);
+ _err = SetMovieColorTable(_self->ob_itself,
+ ctab);
+ if (_err != noErr) return PyMac_Error(_err);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *Qt_NewMovieFromScrap(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_GetMovieColorTable(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Movie _rv;
- long newMovieFlags;
- if (!PyArg_ParseTuple(_args, "l",
- &newMovieFlags))
+ OSErr _err;
+ CTabHandle ctab;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = NewMovieFromScrap(newMovieFlags);
+ _err = GetMovieColorTable(_self->ob_itself,
+ &ctab);
+ if (_err != noErr) return PyMac_Error(_err);
_res = Py_BuildValue("O&",
- MovieObj_New, _rv);
+ ResObj_New, ctab);
return _res;
}
-static PyObject *Qt_MCSetMovie(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_FlattenMovie(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- Movie theMovie;
- WindowPtr movieWindow;
- Point where;
- if (!PyArg_ParseTuple(_args, "O&O&O&O&",
- CmpInstObj_Convert, &mc,
- MovieObj_Convert, &theMovie,
- WinObj_Convert, &movieWindow,
- PyMac_GetPoint, &where))
+ long movieFlattenFlags;
+ FSSpec theFile;
+ OSType creator;
+ ScriptCode scriptTag;
+ long createMovieFileFlags;
+ short resId;
+ Str255 resName;
+ if (!PyArg_ParseTuple(_args, "lO&O&hlO&",
+ &movieFlattenFlags,
+ PyMac_GetFSSpec, &theFile,
+ PyMac_GetOSType, &creator,
+ &scriptTag,
+ &createMovieFileFlags,
+ PyMac_GetStr255, resName))
return NULL;
- _rv = MCSetMovie(mc,
- theMovie,
- movieWindow,
- where);
- _res = Py_BuildValue("l",
- _rv);
+ FlattenMovie(_self->ob_itself,
+ movieFlattenFlags,
+ &theFile,
+ creator,
+ scriptTag,
+ createMovieFileFlags,
+ &resId,
+ resName);
+ _res = Py_BuildValue("h",
+ resId);
return _res;
}
-static PyObject *Qt_MCGetIndMovie(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_FlattenMovieData(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
Movie _rv;
- MovieController mc;
- short index;
- if (!PyArg_ParseTuple(_args, "O&h",
- CmpInstObj_Convert, &mc,
- &index))
+ long movieFlattenFlags;
+ FSSpec theFile;
+ OSType creator;
+ ScriptCode scriptTag;
+ long createMovieFileFlags;
+ if (!PyArg_ParseTuple(_args, "lO&O&hl",
+ &movieFlattenFlags,
+ PyMac_GetFSSpec, &theFile,
+ PyMac_GetOSType, &creator,
+ &scriptTag,
+ &createMovieFileFlags))
return NULL;
- _rv = MCGetIndMovie(mc,
- index);
+ _rv = FlattenMovieData(_self->ob_itself,
+ movieFlattenFlags,
+ &theFile,
+ creator,
+ scriptTag,
+ createMovieFileFlags);
_res = Py_BuildValue("O&",
MovieObj_New, _rv);
return _res;
}
-static PyObject *Qt_MCRemoveMovie(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_MovieSearchText(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
+ OSErr _err;
+ Ptr text;
+ long size;
+ long searchFlags;
+ Track searchTrack;
+ TimeValue searchTime;
+ long searchOffset;
+ 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(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Rect boxRect;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetPosterBox(_self->ob_itself,
+ &boxRect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &boxRect);
+ return _res;
+}
+
+static PyObject *MovieObj_SetPosterBox(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Rect boxRect;
if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ PyMac_GetRect, &boxRect))
return NULL;
- _rv = MCRemoveMovie(mc);
- _res = Py_BuildValue("l",
- _rv);
+ SetPosterBox(_self->ob_itself,
+ &boxRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_MCIsPlayerEvent(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_GetMovieSegmentDisplayBoundsRgn(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- EventRecord e;
- if (!PyArg_ParseTuple(_args, "O&O&",
- CmpInstObj_Convert, &mc,
- PyMac_GetEventRecord, &e))
+ RgnHandle _rv;
+ TimeValue time;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &time,
+ &duration))
return NULL;
- _rv = MCIsPlayerEvent(mc,
- &e);
- _res = Py_BuildValue("l",
- _rv);
+ _rv = GetMovieSegmentDisplayBoundsRgn(_self->ob_itself,
+ time,
+ duration);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
return _res;
}
-static PyObject *Qt_MCSetControllerAttached(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_GetMovieStatus(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
ComponentResult _rv;
- MovieController mc;
- Boolean attach;
- if (!PyArg_ParseTuple(_args, "O&b",
- CmpInstObj_Convert, &mc,
- &attach))
+ Track firstProblemTrack;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = MCSetControllerAttached(mc,
- attach);
- _res = Py_BuildValue("l",
- _rv);
+ _rv = GetMovieStatus(_self->ob_itself,
+ &firstProblemTrack);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ TrackObj_New, firstProblemTrack);
return _res;
}
-static PyObject *Qt_MCIsControllerAttached(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_NewMovieController(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ MovieController _rv;
+ Rect movieRect;
+ long someFlags;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetRect, &movieRect,
+ &someFlags))
return NULL;
- _rv = MCIsControllerAttached(mc);
- _res = Py_BuildValue("l",
- _rv);
+ _rv = NewMovieController(_self->ob_itself,
+ &movieRect,
+ someFlags);
+ _res = Py_BuildValue("O&",
+ MovieCtlObj_New, _rv);
return _res;
}
-static PyObject *Qt_MCSetVisible(_self, _args)
- PyObject *_self;
+static PyObject *MovieObj_PutMovieOnScrap(_self, _args)
+ MovieObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- Boolean visible;
- if (!PyArg_ParseTuple(_args, "O&b",
- CmpInstObj_Convert, &mc,
- &visible))
+ OSErr _err;
+ long movieScrapFlags;
+ if (!PyArg_ParseTuple(_args, "l",
+ &movieScrapFlags))
return NULL;
- _rv = MCSetVisible(mc,
- visible);
- _res = Py_BuildValue("l",
- _rv);
+ _err = PutMovieOnScrap(_self->ob_itself,
+ movieScrapFlags);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_MCGetVisible(_self, _args)
+static PyObject *MovieObj_SetMoviePlayHints(_self, _args)
+ MovieObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long flags;
+ long flagsMask;
+ 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 PyMethodDef MovieObj_methods[] = {
+ {"MoviesTask", (PyCFunction)MovieObj_MoviesTask, 1,
+ "(long maxMilliSecToUse) -> None"},
+ {"PrerollMovie", (PyCFunction)MovieObj_PrerollMovie, 1,
+ "(TimeValue time, Fixed Rate) -> 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)"},
+ {"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"},
+ {"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)"},
+ {"PutMovieIntoHandle", (PyCFunction)MovieObj_PutMovieIntoHandle, 1,
+ "(Handle publicMovie) -> None"},
+ {"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1,
+ "(short fRefNum, long offset, long maxSize) -> None"},
+ {"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)"},
+ {"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)"},
+ {"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)"},
+ {"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)"},
+ {"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"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain MovieObj_chain = { MovieObj_methods, NULL };
+
+static PyObject *MovieObj_getattr(self, name)
+ MovieObject *self;
+ char *name;
+{
+ return Py_FindMethodInChain(&MovieObj_chain, (PyObject *)self, name);
+}
+
+#define MovieObj_setattr NULL
+
+PyTypeObject Movie_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "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*/
+};
+
+/* --------------------- End object type Movie ---------------------- */
+
+
+static PyObject *Qt_EnterMovies(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = MCGetVisible(mc);
- _res = Py_BuildValue("l",
- _rv);
+ _err = EnterMovies();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_MCGetControllerBoundsRect(_self, _args)
+static PyObject *Qt_ExitMovies(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- Rect bounds;
- if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = MCGetControllerBoundsRect(mc,
- &bounds);
- _res = Py_BuildValue("lO&",
- _rv,
- PyMac_BuildRect, &bounds);
+ ExitMovies();
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_MCSetControllerBoundsRect(_self, _args)
+static PyObject *Qt_GetMoviesError(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- Rect bounds;
- if (!PyArg_ParseTuple(_args, "O&O&",
- CmpInstObj_Convert, &mc,
- PyMac_GetRect, &bounds))
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = MCSetControllerBoundsRect(mc,
- &bounds);
- _res = Py_BuildValue("l",
- _rv);
+ _err = GetMoviesError();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_MCGetControllerBoundsRgn(_self, _args)
+static PyObject *Qt_ClearMoviesStickyError(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle _rv;
- MovieController mc;
- if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = MCGetControllerBoundsRgn(mc);
- _res = Py_BuildValue("O&",
- ResObj_New, _rv);
+ ClearMoviesStickyError();
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_MCGetWindowRgn(_self, _args)
+static PyObject *Qt_GetMoviesStickyError(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- RgnHandle _rv;
- MovieController mc;
- WindowPtr w;
- if (!PyArg_ParseTuple(_args, "O&O&",
- CmpInstObj_Convert, &mc,
- WinObj_Convert, &w))
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = MCGetWindowRgn(mc,
- w);
- _res = Py_BuildValue("O&",
- ResObj_New, _rv);
+ _err = GetMoviesStickyError();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_MCMovieChanged(_self, _args)
+static PyObject *Qt_DisposeMatte(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- Movie m;
- if (!PyArg_ParseTuple(_args, "O&O&",
- CmpInstObj_Convert, &mc,
- MovieObj_Convert, &m))
+ PixMapHandle theMatte;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theMatte))
return NULL;
- _rv = MCMovieChanged(mc,
- m);
- _res = Py_BuildValue("l",
- _rv);
+ DisposeMatte(theMatte);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_MCSetDuration(_self, _args)
+static PyObject *Qt_NewMovie(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- TimeValue duration;
- if (!PyArg_ParseTuple(_args, "O&l",
- CmpInstObj_Convert, &mc,
- &duration))
+ Movie _rv;
+ long flags;
+ if (!PyArg_ParseTuple(_args, "l",
+ &flags))
return NULL;
- _rv = MCSetDuration(mc,
- duration);
- _res = Py_BuildValue("l",
- _rv);
+ _rv = NewMovie(flags);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
return _res;
}
-static PyObject *Qt_MCGetCurrentTime(_self, _args)
+static PyObject *Qt_GetDataHandler(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeValue _rv;
- MovieController mc;
- TimeScale scale;
- if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ Component _rv;
+ Handle dataRef;
+ OSType dataHandlerSubType;
+ long flags;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataHandlerSubType,
+ &flags))
return NULL;
- _rv = MCGetCurrentTime(mc,
- &scale);
- _res = Py_BuildValue("ll",
- _rv,
- scale);
+ _rv = GetDataHandler(dataRef,
+ dataHandlerSubType,
+ flags);
+ _res = Py_BuildValue("O&",
+ CmpObj_New, _rv);
return _res;
}
-static PyObject *Qt_MCNewAttachedController(_self, _args)
+static PyObject *Qt_PasteHandleIntoMovie(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
+ OSErr _err;
+ Handle h;
+ OSType handleType;
Movie theMovie;
- WindowPtr w;
- Point where;
- if (!PyArg_ParseTuple(_args, "O&O&O&O&",
- CmpInstObj_Convert, &mc,
+ long flags;
+ ComponentInstance userComp;
+ if (!PyArg_ParseTuple(_args, "O&O&O&lO&",
+ ResObj_Convert, &h,
+ PyMac_GetOSType, &handleType,
MovieObj_Convert, &theMovie,
- WinObj_Convert, &w,
- PyMac_GetPoint, &where))
+ &flags,
+ CmpInstObj_Convert, &userComp))
return NULL;
- _rv = MCNewAttachedController(mc,
- theMovie,
- w,
- where);
- _res = Py_BuildValue("l",
- _rv);
+ _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_MCDraw(_self, _args)
+static PyObject *Qt_TrackTimeToMediaTime(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- WindowPtr w;
- if (!PyArg_ParseTuple(_args, "O&O&",
- CmpInstObj_Convert, &mc,
- WinObj_Convert, &w))
+ TimeValue _rv;
+ TimeValue value;
+ Track theTrack;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &value,
+ TrackObj_Convert, &theTrack))
return NULL;
- _rv = MCDraw(mc,
- w);
+ _rv = TrackTimeToMediaTime(value,
+ theTrack);
_res = Py_BuildValue("l",
_rv);
return _res;
}
-static PyObject *Qt_MCActivate(_self, _args)
+static PyObject *Qt_NewUserData(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- WindowPtr w;
- Boolean activate;
- if (!PyArg_ParseTuple(_args, "O&O&b",
- CmpInstObj_Convert, &mc,
- WinObj_Convert, &w,
- &activate))
+ OSErr _err;
+ UserData theUserData;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = MCActivate(mc,
- w,
- activate);
- _res = Py_BuildValue("l",
- _rv);
+ _err = NewUserData(&theUserData);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ UserDataObj_New, theUserData);
return _res;
}
-static PyObject *Qt_MCIdle(_self, _args)
+static PyObject *Qt_NewUserDataFromHandle(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
+ OSErr _err;
+ Handle h;
+ UserData theUserData;
if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ ResObj_Convert, &h))
return NULL;
- _rv = MCIdle(mc);
- _res = Py_BuildValue("l",
- _rv);
+ _err = NewUserDataFromHandle(h,
+ &theUserData);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ UserDataObj_New, theUserData);
return _res;
}
-static PyObject *Qt_MCKey(_self, _args)
+static PyObject *Qt_CreateMovieFile(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- SInt8 key;
- long modifiers;
- if (!PyArg_ParseTuple(_args, "O&bl",
- CmpInstObj_Convert, &mc,
- &key,
- &modifiers))
+ OSErr _err;
+ FSSpec fileSpec;
+ OSType creator;
+ ScriptCode scriptTag;
+ long createMovieFileFlags;
+ short resRefNum;
+ Movie newmovie;
+ if (!PyArg_ParseTuple(_args, "O&O&hl",
+ PyMac_GetFSSpec, &fileSpec,
+ PyMac_GetOSType, &creator,
+ &scriptTag,
+ &createMovieFileFlags))
return NULL;
- _rv = MCKey(mc,
- key,
- modifiers);
- _res = Py_BuildValue("l",
- _rv);
+ _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_MCClick(_self, _args)
+static PyObject *Qt_OpenMovieFile(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- WindowPtr w;
- Point where;
- long when;
- long modifiers;
- if (!PyArg_ParseTuple(_args, "O&O&O&ll",
- CmpInstObj_Convert, &mc,
- WinObj_Convert, &w,
- PyMac_GetPoint, &where,
- &when,
- &modifiers))
+ OSErr _err;
+ FSSpec fileSpec;
+ short resRefNum;
+ SInt8 permission;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ PyMac_GetFSSpec, &fileSpec,
+ &permission))
return NULL;
- _rv = MCClick(mc,
- w,
- where,
- when,
- modifiers);
- _res = Py_BuildValue("l",
- _rv);
+ _err = OpenMovieFile(&fileSpec,
+ &resRefNum,
+ permission);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ resRefNum);
return _res;
}
-static PyObject *Qt_MCEnableEditing(_self, _args)
+static PyObject *Qt_CloseMovieFile(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- Boolean enabled;
- if (!PyArg_ParseTuple(_args, "O&b",
- CmpInstObj_Convert, &mc,
- &enabled))
+ OSErr _err;
+ short resRefNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &resRefNum))
return NULL;
- _rv = MCEnableEditing(mc,
- enabled);
- _res = Py_BuildValue("l",
- _rv);
+ _err = CloseMovieFile(resRefNum);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_MCIsEditingEnabled(_self, _args)
+static PyObject *Qt_DeleteMovieFile(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- long _rv;
- MovieController mc;
+ OSErr _err;
+ FSSpec fileSpec;
if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ PyMac_GetFSSpec, &fileSpec))
return NULL;
- _rv = MCIsEditingEnabled(mc);
- _res = Py_BuildValue("l",
- _rv);
+ _err = DeleteMovieFile(&fileSpec);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_MCCopy(_self, _args)
+static PyObject *Qt_NewMovieFromFile(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Movie _rv;
- MovieController mc;
- if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ OSErr _err;
+ Movie theMovie;
+ short resRefNum;
+ short newMovieFlags;
+ Boolean dataRefWasChanged;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &resRefNum,
+ &newMovieFlags))
return NULL;
- _rv = MCCopy(mc);
- _res = Py_BuildValue("O&",
- MovieObj_New, _rv);
+ _err = NewMovieFromFile(&theMovie,
+ resRefNum,
+ (short *)0,
+ (StringPtr)0,
+ newMovieFlags,
+ &dataRefWasChanged);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&b",
+ MovieObj_New, theMovie,
+ dataRefWasChanged);
return _res;
}
-static PyObject *Qt_MCCut(_self, _args)
+static PyObject *Qt_NewMovieFromHandle(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- Movie _rv;
- MovieController mc;
- if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ OSErr _err;
+ Movie theMovie;
+ Handle h;
+ short newMovieFlags;
+ Boolean dataRefWasChanged;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ ResObj_Convert, &h,
+ &newMovieFlags))
return NULL;
- _rv = MCCut(mc);
- _res = Py_BuildValue("O&",
- MovieObj_New, _rv);
+ _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_MCPaste(_self, _args)
+static PyObject *Qt_NewMovieFromDataFork(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- Movie srcMovie;
- if (!PyArg_ParseTuple(_args, "O&O&",
- CmpInstObj_Convert, &mc,
- MovieObj_Convert, &srcMovie))
+ OSErr _err;
+ Movie theMovie;
+ short fRefNum;
+ long fileOffset;
+ short newMovieFlags;
+ Boolean dataRefWasChanged;
+ if (!PyArg_ParseTuple(_args, "hlh",
+ &fRefNum,
+ &fileOffset,
+ &newMovieFlags))
return NULL;
- _rv = MCPaste(mc,
- srcMovie);
- _res = Py_BuildValue("l",
- _rv);
+ _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_MCClear(_self, _args)
+static PyObject *Qt_RemoveMovieResource(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ OSErr _err;
+ short resRefNum;
+ short resId;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &resRefNum,
+ &resId))
return NULL;
- _rv = MCClear(mc);
- _res = Py_BuildValue("l",
- _rv);
+ _err = RemoveMovieResource(resRefNum,
+ resId);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_MCUndo(_self, _args)
+static PyObject *Qt_GetVideoMediaGraphicsMode(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
+ HandlerError _rv;
+ MediaHandler mh;
+ long graphicsMode;
+ RGBColor opColor;
if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ CmpInstObj_Convert, &mh))
return NULL;
- _rv = MCUndo(mc);
- _res = Py_BuildValue("l",
- _rv);
+ _rv = GetVideoMediaGraphicsMode(mh,
+ &graphicsMode,
+ &opColor);
+ _res = Py_BuildValue("llO&",
+ _rv,
+ graphicsMode,
+ QdRGB_New, &opColor);
return _res;
}
-static PyObject *Qt_MCPositionController(_self, _args)
+static PyObject *Qt_SetVideoMediaGraphicsMode(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- Rect movieRect;
- Rect controllerRect;
- long someFlags;
- if (!PyArg_ParseTuple(_args, "O&O&O&l",
- CmpInstObj_Convert, &mc,
- PyMac_GetRect, &movieRect,
- PyMac_GetRect, &controllerRect,
- &someFlags))
+ HandlerError _rv;
+ MediaHandler mh;
+ long graphicsMode;
+ RGBColor opColor;
+ if (!PyArg_ParseTuple(_args, "O&lO&",
+ CmpInstObj_Convert, &mh,
+ &graphicsMode,
+ QdRGB_Convert, &opColor))
return NULL;
- _rv = MCPositionController(mc,
- &movieRect,
- &controllerRect,
- someFlags);
+ _rv = SetVideoMediaGraphicsMode(mh,
+ graphicsMode,
+ &opColor);
_res = Py_BuildValue("l",
_rv);
return _res;
}
-static PyObject *Qt_MCGetControllerInfo(_self, _args)
+static PyObject *Qt_GetSoundMediaBalance(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- long someFlags;
+ HandlerError _rv;
+ MediaHandler mh;
+ short balance;
if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ CmpInstObj_Convert, &mh))
return NULL;
- _rv = MCGetControllerInfo(mc,
- &someFlags);
- _res = Py_BuildValue("ll",
+ _rv = GetSoundMediaBalance(mh,
+ &balance);
+ _res = Py_BuildValue("lh",
_rv,
- someFlags);
+ balance);
return _res;
}
-static PyObject *Qt_MCSetClip(_self, _args)
+static PyObject *Qt_SetSoundMediaBalance(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- RgnHandle theClip;
- RgnHandle movieClip;
- if (!PyArg_ParseTuple(_args, "O&O&O&",
- CmpInstObj_Convert, &mc,
- ResObj_Convert, &theClip,
- ResObj_Convert, &movieClip))
+ HandlerError _rv;
+ MediaHandler mh;
+ short balance;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ CmpInstObj_Convert, &mh,
+ &balance))
return NULL;
- _rv = MCSetClip(mc,
- theClip,
- movieClip);
+ _rv = SetSoundMediaBalance(mh,
+ balance);
_res = Py_BuildValue("l",
_rv);
return _res;
}
-static PyObject *Qt_MCGetClip(_self, _args)
+static PyObject *Qt_FindNextText(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
ComponentResult _rv;
- MovieController mc;
- RgnHandle theClip;
- RgnHandle movieClip;
- if (!PyArg_ParseTuple(_args, "O&",
- CmpInstObj_Convert, &mc))
+ MediaHandler mh;
+ Ptr text;
+ long size;
+ short findFlags;
+ TimeValue startTime;
+ TimeValue foundTime;
+ TimeValue foundDuration;
+ long offset;
+ if (!PyArg_ParseTuple(_args, "O&slhl",
+ CmpInstObj_Convert, &mh,
+ &text,
+ &size,
+ &findFlags,
+ &startTime))
return NULL;
- _rv = MCGetClip(mc,
- &theClip,
- &movieClip);
- _res = Py_BuildValue("lO&O&",
+ _rv = FindNextText(mh,
+ text,
+ size,
+ findFlags,
+ startTime,
+ &foundTime,
+ &foundDuration,
+ &offset);
+ _res = Py_BuildValue("llll",
_rv,
- ResObj_New, theClip,
- ResObj_New, movieClip);
+ foundTime,
+ foundDuration,
+ offset);
return _res;
}
-static PyObject *Qt_MCDrawBadge(_self, _args)
+static PyObject *Qt_NewMovieFromScrap(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- RgnHandle movieRgn;
- RgnHandle badgeRgn;
- if (!PyArg_ParseTuple(_args, "O&O&",
- CmpInstObj_Convert, &mc,
- ResObj_Convert, &movieRgn))
+ Movie _rv;
+ long newMovieFlags;
+ if (!PyArg_ParseTuple(_args, "l",
+ &newMovieFlags))
return NULL;
- _rv = MCDrawBadge(mc,
- movieRgn,
- &badgeRgn);
- _res = Py_BuildValue("lO&",
- _rv,
- ResObj_New, badgeRgn);
+ _rv = NewMovieFromScrap(newMovieFlags);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
return _res;
}
-static PyObject *Qt_MCSetUpEditMenu(_self, _args)
+static PyObject *Qt_NewTimeBase(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- long modifiers;
- MenuHandle mh;
- if (!PyArg_ParseTuple(_args, "O&lO&",
- CmpInstObj_Convert, &mc,
- &modifiers,
- MenuObj_Convert, &mh))
+ TimeBase _rv;
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = MCSetUpEditMenu(mc,
- modifiers,
- mh);
- _res = Py_BuildValue("l",
- _rv);
+ _rv = NewTimeBase();
+ _res = Py_BuildValue("O&",
+ TimeBaseObj_New, _rv);
return _res;
}
-static PyObject *Qt_MCGetMenuString(_self, _args)
+static PyObject *Qt_AlignWindow(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- ComponentResult _rv;
- MovieController mc;
- long modifiers;
- short item;
- Str255 aString;
- if (!PyArg_ParseTuple(_args, "O&lhO&",
- CmpInstObj_Convert, &mc,
- &modifiers,
- &item,
- PyMac_GetStr255, aString))
+ WindowPtr wp;
+ Boolean front;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ WinObj_Convert, &wp,
+ &front))
return NULL;
- _rv = MCGetMenuString(mc,
- modifiers,
- item,
- aString);
- _res = Py_BuildValue("l",
- _rv);
+ AlignWindow(wp,
+ front,
+ (Rect *)0,
+ (ICMAlignmentProcRecordPtr)0);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
-static PyObject *Qt_NewTimeBase(_self, _args)
+static PyObject *Qt_DragAlignedWindow(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
- TimeBase _rv;
- if (!PyArg_ParseTuple(_args, ""))
- return NULL;
- _rv = NewTimeBase();
- _res = Py_BuildValue("O&",
- TimeBaseObj_New, _rv);
+ WindowPtr wp;
+ Point startPt;
+ Rect boundsRect;
+ 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;
}
{"DeleteMovieFile", (PyCFunction)Qt_DeleteMovieFile, 1,
"(FSSpec fileSpec) -> None"},
{"NewMovieFromFile", (PyCFunction)Qt_NewMovieFromFile, 1,
- "(short resRefNum, StringPtr resName, short newMovieFlags) -> (Movie theMovie, short resId, Boolean dataRefWasChanged)"},
+ "(short resRefNum, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
{"NewMovieFromHandle", (PyCFunction)Qt_NewMovieFromHandle, 1,
"(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
{"NewMovieFromDataFork", (PyCFunction)Qt_NewMovieFromDataFork, 1,
"(MediaHandler mh, short balance) -> (HandlerError _rv)"},
{"FindNextText", (PyCFunction)Qt_FindNextText, 1,
"(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)"},
- {"DisposeMovieController", (PyCFunction)Qt_DisposeMovieController, 1,
- "(ComponentInstance mc) -> None"},
{"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1,
"(long newMovieFlags) -> (Movie _rv)"},
- {"MCSetMovie", (PyCFunction)Qt_MCSetMovie, 1,
- "(MovieController mc, Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)"},
- {"MCGetIndMovie", (PyCFunction)Qt_MCGetIndMovie, 1,
- "(MovieController mc, short index) -> (Movie _rv)"},
- {"MCRemoveMovie", (PyCFunction)Qt_MCRemoveMovie, 1,
- "(MovieController mc) -> (ComponentResult _rv)"},
- {"MCIsPlayerEvent", (PyCFunction)Qt_MCIsPlayerEvent, 1,
- "(MovieController mc, EventRecord e) -> (ComponentResult _rv)"},
- {"MCSetControllerAttached", (PyCFunction)Qt_MCSetControllerAttached, 1,
- "(MovieController mc, Boolean attach) -> (ComponentResult _rv)"},
- {"MCIsControllerAttached", (PyCFunction)Qt_MCIsControllerAttached, 1,
- "(MovieController mc) -> (ComponentResult _rv)"},
- {"MCSetVisible", (PyCFunction)Qt_MCSetVisible, 1,
- "(MovieController mc, Boolean visible) -> (ComponentResult _rv)"},
- {"MCGetVisible", (PyCFunction)Qt_MCGetVisible, 1,
- "(MovieController mc) -> (ComponentResult _rv)"},
- {"MCGetControllerBoundsRect", (PyCFunction)Qt_MCGetControllerBoundsRect, 1,
- "(MovieController mc) -> (ComponentResult _rv, Rect bounds)"},
- {"MCSetControllerBoundsRect", (PyCFunction)Qt_MCSetControllerBoundsRect, 1,
- "(MovieController mc, Rect bounds) -> (ComponentResult _rv)"},
- {"MCGetControllerBoundsRgn", (PyCFunction)Qt_MCGetControllerBoundsRgn, 1,
- "(MovieController mc) -> (RgnHandle _rv)"},
- {"MCGetWindowRgn", (PyCFunction)Qt_MCGetWindowRgn, 1,
- "(MovieController mc, WindowPtr w) -> (RgnHandle _rv)"},
- {"MCMovieChanged", (PyCFunction)Qt_MCMovieChanged, 1,
- "(MovieController mc, Movie m) -> (ComponentResult _rv)"},
- {"MCSetDuration", (PyCFunction)Qt_MCSetDuration, 1,
- "(MovieController mc, TimeValue duration) -> (ComponentResult _rv)"},
- {"MCGetCurrentTime", (PyCFunction)Qt_MCGetCurrentTime, 1,
- "(MovieController mc) -> (TimeValue _rv, TimeScale scale)"},
- {"MCNewAttachedController", (PyCFunction)Qt_MCNewAttachedController, 1,
- "(MovieController mc, Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)"},
- {"MCDraw", (PyCFunction)Qt_MCDraw, 1,
- "(MovieController mc, WindowPtr w) -> (ComponentResult _rv)"},
- {"MCActivate", (PyCFunction)Qt_MCActivate, 1,
- "(MovieController mc, WindowPtr w, Boolean activate) -> (ComponentResult _rv)"},
- {"MCIdle", (PyCFunction)Qt_MCIdle, 1,
- "(MovieController mc) -> (ComponentResult _rv)"},
- {"MCKey", (PyCFunction)Qt_MCKey, 1,
- "(MovieController mc, SInt8 key, long modifiers) -> (ComponentResult _rv)"},
- {"MCClick", (PyCFunction)Qt_MCClick, 1,
- "(MovieController mc, WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)"},
- {"MCEnableEditing", (PyCFunction)Qt_MCEnableEditing, 1,
- "(MovieController mc, Boolean enabled) -> (ComponentResult _rv)"},
- {"MCIsEditingEnabled", (PyCFunction)Qt_MCIsEditingEnabled, 1,
- "(MovieController mc) -> (long _rv)"},
- {"MCCopy", (PyCFunction)Qt_MCCopy, 1,
- "(MovieController mc) -> (Movie _rv)"},
- {"MCCut", (PyCFunction)Qt_MCCut, 1,
- "(MovieController mc) -> (Movie _rv)"},
- {"MCPaste", (PyCFunction)Qt_MCPaste, 1,
- "(MovieController mc, Movie srcMovie) -> (ComponentResult _rv)"},
- {"MCClear", (PyCFunction)Qt_MCClear, 1,
- "(MovieController mc) -> (ComponentResult _rv)"},
- {"MCUndo", (PyCFunction)Qt_MCUndo, 1,
- "(MovieController mc) -> (ComponentResult _rv)"},
- {"MCPositionController", (PyCFunction)Qt_MCPositionController, 1,
- "(MovieController mc, Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)"},
- {"MCGetControllerInfo", (PyCFunction)Qt_MCGetControllerInfo, 1,
- "(MovieController mc) -> (ComponentResult _rv, long someFlags)"},
- {"MCSetClip", (PyCFunction)Qt_MCSetClip, 1,
- "(MovieController mc, RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)"},
- {"MCGetClip", (PyCFunction)Qt_MCGetClip, 1,
- "(MovieController mc) -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)"},
- {"MCDrawBadge", (PyCFunction)Qt_MCDrawBadge, 1,
- "(MovieController mc, RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)"},
- {"MCSetUpEditMenu", (PyCFunction)Qt_MCSetUpEditMenu, 1,
- "(MovieController mc, long modifiers, MenuHandle mh) -> (ComponentResult _rv)"},
- {"MCGetMenuString", (PyCFunction)Qt_MCGetMenuString, 1,
- "(MovieController mc, long modifiers, short item, Str255 aString) -> (ComponentResult _rv)"},
{"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1,
"() -> (TimeBase _rv)"},
+ {"AlignWindow", (PyCFunction)Qt_AlignWindow, 1,
+ "(WindowPtr wp, Boolean front) -> None"},
+ {"DragAlignedWindow", (PyCFunction)Qt_DragAlignedWindow, 1,
+ "(WindowPtr wp, Point startPt, Rect boundsRect) -> None"},
{NULL, NULL, 0}
};
projects / python / commitdiff