From 9cfea10bf2fbebd65a2f81e60bc48576c905ee9e Mon Sep 17 00:00:00 2001 From: Jack Jansen Date: Sat, 9 Dec 1995 14:05:56 +0000 Subject: It now actually works. Also, MovieInWindow and VerySimplePlayer example programs translated to python and added. --- Mac/Demo/quicktime/MovieInWindow.py | 71 + Mac/Demo/quicktime/VerySimplePlayer.py | 97 + Mac/Modules/qt/Qtmodule.c | 7301 ++++++++++++++++---------------- Mac/Modules/qt/qtgen.py | 158 +- Mac/Modules/qt/qtscan.py | 15 +- Mac/Modules/qt/qtsupport.py | 51 +- 6 files changed, 3985 insertions(+), 3708 deletions(-) create mode 100644 Mac/Demo/quicktime/MovieInWindow.py create mode 100644 Mac/Demo/quicktime/VerySimplePlayer.py diff --git a/Mac/Demo/quicktime/MovieInWindow.py b/Mac/Demo/quicktime/MovieInWindow.py new file mode 100644 index 0000000..8ff3b42 --- /dev/null +++ b/Mac/Demo/quicktime/MovieInWindow.py @@ -0,0 +1,71 @@ +"""MovieInWindow converted to python + +Jack Jansen, CWI, December 1995 +""" + +import addpack +addpack.addpack(':Tools:bgen:qt') +addpack.addpack(':Tools:bgen:qd') +addpack.addpack(':Tools:bgen:evt') +addpack.addpack(':Tools:bgen:win') +import Qt +import QuickTime +import Qd +import QuickDraw +import Evt +import Events +import Win +import Windows +import macfs +import sys + + +def main(): + # skip the toolbox initializations, already done + # XXXX Should use gestalt here to check for quicktime version + Qt.EnterMovies() + + # Get the movie file + fss, ok = macfs.StandardGetFile(QuickTime.MovieFileType) + if not ok: + sys.exit(0) + + # Open the window + bounds = (175, 75, 175+160, 75+120) + theWindow = Win.NewCWindow(bounds, fss.as_tuple()[2], 1, 0, -1, 0, 0) + Qd.SetPort(theWindow) + # XXXX Needed? SetGWorld((CGrafPtr)theWindow, nil) + + playMovieInWindow(theWindow, fss, theWindow.GetWindowPort().portRect) + +def playMovieInWindow(theWindow, theFile, movieBox): + """Play a movie in a window""" + # XXXX Needed? SetGWorld((CGrafPtr)theWindow, nil); + + # Get the movie + theMovie = loadMovie(theFile) + + # Set where we want it + theMovie.SetMovieBox(movieBox) + + # Start at the beginning + theMovie.GoToBeginningOfMovie() + + # Give a little time to preroll + theMovie.MoviesTask(0) + + # Start playing + theMovie.StartMovie() + + while not theMovie.IsMovieDone() and not Evt.Button(): + theMovie.MoviesTask(0) + +def loadMovie(theFile): + """Load a movie given an fsspec. Return the movie object""" + movieResRef = Qt.OpenMovieFile(theFile, 1) + movie, dummy = Qt.NewMovieFromFile(movieResRef, QuickTime.newMovieActive) + return movie + +if __name__ == '__main__': + main() + diff --git a/Mac/Demo/quicktime/VerySimplePlayer.py b/Mac/Demo/quicktime/VerySimplePlayer.py new file mode 100644 index 0000000..24c97fb --- /dev/null +++ b/Mac/Demo/quicktime/VerySimplePlayer.py @@ -0,0 +1,97 @@ +"""VerySimplePlayer converted to python + +Jack Jansen, CWI, December 1995 +""" + +import addpack +addpack.addpack(':Tools:bgen:qt') +addpack.addpack(':Tools:bgen:qd') +addpack.addpack(':Tools:bgen:evt') +addpack.addpack(':Tools:bgen:win') +import Qt +import QuickTime +import Qd +import QuickDraw +import Evt +import Events +import Win +import Windows +import macfs +import sys + +# XXXX maxbounds = (40, 40, 1000, 1000) + +def main(): + print 'hello world' # XXXX + # skip the toolbox initializations, already done + # XXXX Should use gestalt here to check for quicktime version + Qt.EnterMovies() + + # Get the movie file + fss, ok = macfs.StandardGetFile(QuickTime.MovieFileType) + if not ok: + sys.exit(0) + + # Open the window + bounds = (175, 75, 175+160, 75+120) + theWindow = Win.NewCWindow(bounds, fss.as_tuple()[2], 0, 0, -1, 1, 0) + # XXXX Needed? SetGWorld((CGrafPtr)theWindow, nil) + Qd.SetPort(theWindow) + + # Get the movie + theMovie = loadMovie(fss) + + # Relocate to (0, 0) + bounds = theMovie.GetMovieBox() + bounds = 0, 0, bounds[2]-bounds[0], bounds[3]-bounds[1] + theMovie.SetMovieBox(bounds) + + # Create a controller + theController = theMovie.NewMovieController(bounds, QuickTime.mcTopLeftMovie) + + # Get movie size and update window parameters + rv, bounds = theController.MCGetControllerBoundsRect() + theWindow.SizeWindow(bounds[2], bounds[3], 0) # XXXX or [3] [2]? + Qt.AlignWindow(theWindow, 0) + theWindow.ShowWindow() + + # XXXX MCDoAction(theController, mcActionSetGrowBoxBounds, &maxBounds) + theController.MCDoAction(QuickTime.mcActionSetKeysEnabled, '1') + + # XXXX MCSetActionFilterWithRefCon(theController, movieControllerEventFilter, (long)theWindow) + + done = 0 + while not done: + gotone, evt = Evt.WaitNextEvent(-1, 0) + (what, message, when, where, modifiers) = evt +## print what, message, when, where, modifiers # XXXX + + if theController.MCIsPlayerEvent(evt): + continue + + if what == Events.mouseDown: + part, whichWindow = Win.FindWindow(where) + if part == Windows.inGoAway: + done = whichWindow.TrackGoAway(where) + elif part == Windows.inDrag: + Qt.DragAlignedWindow(whichWindow, where, (0, 0, 4000, 4000)) + elif what == Events.updateEvt: + whichWindow = Win.WhichWindow(message) + if not whichWindow: + # Probably the console window. Print something, hope it helps. + print 'update' + else: + Qd.SetPort(whichWindow) + whichWindow.BeginUpdate() + Qd.EraseRect(whichWindow.GetWindowPort().portRect) + whichWindow.EndUpdate() + +def loadMovie(theFile): + """Load a movie given an fsspec. Return the movie object""" + movieResRef = Qt.OpenMovieFile(theFile, 1) + movie, dummy = Qt.NewMovieFromFile(movieResRef, QuickTime.newMovieActive) + return movie + +if __name__ == '__main__': + main() + diff --git a/Mac/Modules/qt/Qtmodule.c b/Mac/Modules/qt/Qtmodule.c index c601292..6a6533b 100644 --- a/Mac/Modules/qt/Qtmodule.c +++ b/Mac/Modules/qt/Qtmodule.c @@ -58,1564 +58,1343 @@ staticforward PyObject *TrackObj_New(Track); 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; @@ -1628,7 +1407,7 @@ static PyObject *TrackObj_LoadTrackIntoRam(_self, _args) &duration, &flags)) return NULL; - _err = LoadTrackIntoRam(_self->ob_itself, + _err = LoadMediaIntoRam(_self->ob_itself, time, duration, flags); @@ -1638,4163 +1417,4507 @@ static PyObject *TrackObj_LoadTrackIntoRam(_self, _args) 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; } @@ -5832,7 +5955,7 @@ static PyMethodDef Qt_methods[] = { {"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, @@ -5849,82 +5972,14 @@ static PyMethodDef Qt_methods[] = { "(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} }; diff --git a/Mac/Modules/qt/qtgen.py b/Mac/Modules/qt/qtgen.py index 2fe1742..b10312e 100644 --- a/Mac/Modules/qt/qtgen.py +++ b/Mac/Modules/qt/qtgen.py @@ -1160,8 +1160,8 @@ functions.append(f) f = Function(OSErr, 'NewMovieFromFile', (Movie, 'theMovie', OutMode), (short, 'resRefNum', InMode), - (short, 'resId', OutMode), - (StringPtr, 'resName', InMode), + (dummyshortptr, 'resId', InMode), + (dummyStringPtr, 'resName', InMode), (short, 'newMovieFlags', InMode), (Boolean, 'dataRefWasChanged', OutMode), ) @@ -1350,18 +1350,13 @@ f = Method(ComponentResult, 'GetMovieStatus', ) Movie_methods.append(f) -f = Method(ComponentInstance, 'NewMovieController', +f = Method(MovieController, 'NewMovieController', (Movie, 'theMovie', InMode), (Rect_ptr, 'movieRect', InMode), (long, 'someFlags', InMode), ) Movie_methods.append(f) -f = Function(void, 'DisposeMovieController', - (ComponentInstance, 'mc', InMode), -) -functions.append(f) - f = Method(OSErr, 'PutMovieOnScrap', (Movie, 'theMovie', InMode), (long, 'movieScrapFlags', InMode), @@ -1443,222 +1438,229 @@ f = Method(void, 'GetTrackLoadSettings', ) Track_methods.append(f) -f = Function(ComponentResult, 'MCSetMovie', +f = Method(ComponentResult, 'MCSetMovie', (MovieController, 'mc', InMode), (Movie, 'theMovie', InMode), (WindowPtr, 'movieWindow', InMode), (Point, 'where', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(Movie, 'MCGetIndMovie', +f = Method(Movie, 'MCGetIndMovie', (MovieController, 'mc', InMode), (short, 'index', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCRemoveMovie', +f = Method(ComponentResult, 'MCRemoveMovie', (MovieController, 'mc', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCIsPlayerEvent', +f = Method(ComponentResult, 'MCIsPlayerEvent', (MovieController, 'mc', InMode), (EventRecord_ptr, 'e', InMode), ) -functions.append(f) +MovieController_methods.append(f) + +f = Method(ComponentResult, 'MCDoAction', + (MovieController, 'mc', InMode), + (short, 'action', InMode), + (mcactionparams, 'params', InMode), +) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCSetControllerAttached', +f = Method(ComponentResult, 'MCSetControllerAttached', (MovieController, 'mc', InMode), (Boolean, 'attach', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCIsControllerAttached', +f = Method(ComponentResult, 'MCIsControllerAttached', (MovieController, 'mc', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCSetVisible', +f = Method(ComponentResult, 'MCSetVisible', (MovieController, 'mc', InMode), (Boolean, 'visible', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCGetVisible', +f = Method(ComponentResult, 'MCGetVisible', (MovieController, 'mc', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCGetControllerBoundsRect', +f = Method(ComponentResult, 'MCGetControllerBoundsRect', (MovieController, 'mc', InMode), (Rect, 'bounds', OutMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCSetControllerBoundsRect', +f = Method(ComponentResult, 'MCSetControllerBoundsRect', (MovieController, 'mc', InMode), (Rect_ptr, 'bounds', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(RgnHandle, 'MCGetControllerBoundsRgn', +f = Method(RgnHandle, 'MCGetControllerBoundsRgn', (MovieController, 'mc', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(RgnHandle, 'MCGetWindowRgn', +f = Method(RgnHandle, 'MCGetWindowRgn', (MovieController, 'mc', InMode), (WindowPtr, 'w', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCMovieChanged', +f = Method(ComponentResult, 'MCMovieChanged', (MovieController, 'mc', InMode), (Movie, 'm', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCSetDuration', +f = Method(ComponentResult, 'MCSetDuration', (MovieController, 'mc', InMode), (TimeValue, 'duration', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(TimeValue, 'MCGetCurrentTime', +f = Method(TimeValue, 'MCGetCurrentTime', (MovieController, 'mc', InMode), (TimeScale, 'scale', OutMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCNewAttachedController', +f = Method(ComponentResult, 'MCNewAttachedController', (MovieController, 'mc', InMode), (Movie, 'theMovie', InMode), (WindowPtr, 'w', InMode), (Point, 'where', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCDraw', +f = Method(ComponentResult, 'MCDraw', (MovieController, 'mc', InMode), (WindowPtr, 'w', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCActivate', +f = Method(ComponentResult, 'MCActivate', (MovieController, 'mc', InMode), (WindowPtr, 'w', InMode), (Boolean, 'activate', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCIdle', +f = Method(ComponentResult, 'MCIdle', (MovieController, 'mc', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCKey', +f = Method(ComponentResult, 'MCKey', (MovieController, 'mc', InMode), (SInt8, 'key', InMode), (long, 'modifiers', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCClick', +f = Method(ComponentResult, 'MCClick', (MovieController, 'mc', InMode), (WindowPtr, 'w', InMode), (Point, 'where', InMode), (long, 'when', InMode), (long, 'modifiers', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCEnableEditing', +f = Method(ComponentResult, 'MCEnableEditing', (MovieController, 'mc', InMode), (Boolean, 'enabled', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(long, 'MCIsEditingEnabled', +f = Method(long, 'MCIsEditingEnabled', (MovieController, 'mc', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(Movie, 'MCCopy', +f = Method(Movie, 'MCCopy', (MovieController, 'mc', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(Movie, 'MCCut', +f = Method(Movie, 'MCCut', (MovieController, 'mc', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCPaste', +f = Method(ComponentResult, 'MCPaste', (MovieController, 'mc', InMode), (Movie, 'srcMovie', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCClear', +f = Method(ComponentResult, 'MCClear', (MovieController, 'mc', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCUndo', +f = Method(ComponentResult, 'MCUndo', (MovieController, 'mc', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCPositionController', +f = Method(ComponentResult, 'MCPositionController', (MovieController, 'mc', InMode), (Rect_ptr, 'movieRect', InMode), (Rect_ptr, 'controllerRect', InMode), (long, 'someFlags', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCGetControllerInfo', +f = Method(ComponentResult, 'MCGetControllerInfo', (MovieController, 'mc', InMode), (long, 'someFlags', OutMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCSetClip', +f = Method(ComponentResult, 'MCSetClip', (MovieController, 'mc', InMode), (RgnHandle, 'theClip', InMode), (RgnHandle, 'movieClip', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCGetClip', +f = Method(ComponentResult, 'MCGetClip', (MovieController, 'mc', InMode), (RgnHandle, 'theClip', OutMode), (RgnHandle, 'movieClip', OutMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCDrawBadge', +f = Method(ComponentResult, 'MCDrawBadge', (MovieController, 'mc', InMode), (RgnHandle, 'movieRgn', InMode), (RgnHandle, 'badgeRgn', OutMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCSetUpEditMenu', +f = Method(ComponentResult, 'MCSetUpEditMenu', (MovieController, 'mc', InMode), (long, 'modifiers', InMode), (MenuHandle, 'mh', InMode), ) -functions.append(f) +MovieController_methods.append(f) -f = Function(ComponentResult, 'MCGetMenuString', +f = Method(ComponentResult, 'MCGetMenuString', (MovieController, 'mc', InMode), (long, 'modifiers', InMode), (short, 'item', InMode), (Str255, 'aString', InMode), ) -functions.append(f) +MovieController_methods.append(f) f = Function(TimeBase, 'NewTimeBase', ) diff --git a/Mac/Modules/qt/qtscan.py b/Mac/Modules/qt/qtscan.py index 83683fe..020c487 100644 --- a/Mac/Modules/qt/qtscan.py +++ b/Mac/Modules/qt/qtscan.py @@ -6,7 +6,7 @@ from scantools import Scanner LONG = "QuickTime" SHORT = "qt" -OBJECTS = ("Movie", "Track", "Media", "UserData", "TimeBase") +OBJECTS = ("Movie", "Track", "Media", "UserData", "TimeBase", "MovieController") def main(): input = "Movies.h" @@ -38,6 +38,7 @@ class MyScanner(Scanner): "DisposeTrackMedia", # ditto "DisposeUserData", # ditto "DisposeTimeBase", # ditto + "DisposeMovieController", # ditto "GetMovieCreationTime", # type "unsigned long" in C, inparseable "GetMovieModificationTime", # Ditto "GetTrackCreationTime", # ditto @@ -49,7 +50,6 @@ class MyScanner(Scanner): "GetUserDataItem", "SetUserDataItem", "SetTextSampleData", - "MCDoAction", # bgen gets the argument in/out wrong.. "AddTextSample", "AddTESample", @@ -95,6 +95,17 @@ class MyScanner(Scanner): def makerepairinstructions(self): return [ ([('FSSpec', '*', 'OutMode')], [('FSSpec_ptr', '*', 'InMode')]), + + # Movie controller creation + ([('ComponentInstance', 'NewMovieController', 'ReturnMode')], + [('MovieController', '*', 'ReturnMode')]), + + # NewMovieFromFile + ([('short', 'resId', 'OutMode'), ('StringPtr', 'resName', 'InMode')], + [('dummyshortptr', 'resId', 'InMode'), ('dummyStringPtr', 'resName', 'InMode')]), + + # MCDoAction + ([('void', 'params', 'OutMode')], [('mcactionparams', 'params', 'InMode')]), ] if __name__ == "__main__": diff --git a/Mac/Modules/qt/qtsupport.py b/Mac/Modules/qt/qtsupport.py index ef5cac7..17ba808 100644 --- a/Mac/Modules/qt/qtsupport.py +++ b/Mac/Modules/qt/qtsupport.py @@ -3,6 +3,8 @@ # The function specifications are generated by scanning the mamager's header file, # using the "scantools" package (customized for this particular manager). +#error missing SetActionFilter + import string # Declarations that change for each manager @@ -39,6 +41,8 @@ staticforward PyObject *TrackObj_New(Track); 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 *); """ @@ -49,6 +53,7 @@ Track = OpaqueByValueType('Track', 'TrackObj') Media = OpaqueByValueType('Media', 'MediaObj') UserData = OpaqueByValueType('UserData', 'UserDataObj') TimeBase = OpaqueByValueType('TimeBase', 'TimeBaseObj') +MovieController = OpaqueByValueType('MovieController', 'MovieCtlObj') # Other opaque objects Component = OpaqueByValueType('Component', 'CmpObj') @@ -58,10 +63,6 @@ DataHandlerComponent = OpaqueByValueType('DataHandlerComponent', 'CmpObj') ComponentInstance = OpaqueByValueType('ComponentInstance', 'CmpInstObj') MediaHandler = OpaqueByValueType('MediaHandler', 'CmpInstObj') DataHandler = OpaqueByValueType('DataHandler', 'CmpInstObj') -# XXXX The next one should really be a full-fledged object here, but the -# type is sometimes specified as MovieController and some times as -# ComponentInstance. -MovieController = OpaqueByValueType('MovieController', 'CmpInstObj') RgnHandle = OpaqueByValueType("RgnHandle", "ResObj") PicHandle = OpaqueByValueType("PicHandle", "ResObj") @@ -91,8 +92,12 @@ mediaHandlerFlagsEnum = Type("mediaHandlerFlagsEnum", "l") ComponentResult = Type("ComponentResult", "l") HandlerError = Type("HandlerError", "l") Ptr = InputOnlyType("Ptr", "s") -StringPtr = InputOnlyType("StringPtr", "s") +StringPtr = Type("StringPtr", "s") +mcactionparams = InputOnlyType("void *", "s") +# Could-not-be-bothered-types (NewMovieFromFile) +dummyshortptr = FakeType('(short *)0') +dummyStringPtr = FakeType('(StringPtr)0') class MovieObjectDefinition(GlobalObjectDefinition): def outputCheckNewArg(self): @@ -139,6 +144,15 @@ class TimeBaseObjectDefinition(GlobalObjectDefinition): def outputFreeIt(self, itselfname): Output("DisposeTimeBase(%s);", itselfname) +class MovieCtlObjectDefinition(GlobalObjectDefinition): + def outputCheckNewArg(self): + Output("""if (itself == NULL) { + PyErr_SetString(Qt_Error,"Cannot create null MovieController"); + return NULL; + }""") + def outputFreeIt(self, itselfname): + Output("DisposeMovieController(%s);", itselfname) + # From here on it's basically all boiler plate... # Create the generator groups and link them @@ -148,7 +162,9 @@ Track_object = TrackObjectDefinition('Track', 'TrackObj', 'Track') Media_object = MediaObjectDefinition('Media', 'MediaObj', 'Media') UserData_object = UserDataObjectDefinition('UserData', 'UserDataObj', 'UserData') TimeBase_object = TimeBaseObjectDefinition('TimeBase', 'TimeBaseObj', 'TimeBase') +MovieController_object = MovieCtlObjectDefinition('MovieController', 'MovieCtlObj', 'MovieController') +module.addobject(MovieController_object) module.addobject(TimeBase_object) module.addobject(UserData_object) module.addobject(Media_object) @@ -161,6 +177,7 @@ Method = OSErrMethodGenerator # Create and populate the lists functions = [] +MovieController_methods = [] TimeBase_methods = [] UserData_methods = [] Media_methods = [] @@ -168,9 +185,33 @@ Track_methods = [] Movie_methods = [] execfile(INPUTFILE) +# +# Some functions from ImageCompression.h that we need: +ICMAlignmentProcRecordPtr = FakeType('(ICMAlignmentProcRecordPtr)0') +dummyRect = FakeType('(Rect *)0') + +f = Function(void, 'AlignWindow', + (WindowPtr, 'wp', InMode), + (Boolean, 'front', InMode), + (dummyRect, 'alignmentRect', InMode), + (ICMAlignmentProcRecordPtr, 'alignmentProc', InMode), +) +functions.append(f) + +f = Function(void, 'DragAlignedWindow', + (WindowPtr, 'wp', InMode), + (Point, 'startPt', InMode), + (Rect_ptr, 'boundsRect', InMode), + (dummyRect, 'alignmentRect', InMode), + (ICMAlignmentProcRecordPtr, 'alignmentProc', InMode), +) +functions.append(f) + + # add the populated lists to the generator groups # (in a different wordl the scan program would generate this) for f in functions: module.add(f) +for f in MovieController_methods: MovieController_object.add(f) for f in TimeBase_methods: TimeBase_object.add(f) for f in UserData_methods: UserData_object.add(f) for f in Media_methods: Media_object.add(f) -- cgit v0.12