From 453ced57dc55e4a04b8b0039f3899b99e8cdaa43 Mon Sep 17 00:00:00 2001 From: Jack Jansen Date: Thu, 30 Nov 1995 17:42:08 +0000 Subject: [PATCH] still untested (but it compiles) --- Mac/Modules/qt/Qtmodule.c | 5951 +++++++++++++++++++++++++++++++++++ Mac/Modules/qt/qtgen.py | 1101 ++++++- Mac/Modules/qt/qtscan.py | 59 +- Mac/Modules/qt/qtsupport.py | 128 +- 4 files changed, 7039 insertions(+), 200 deletions(-) create mode 100644 Mac/Modules/qt/Qtmodule.c diff --git a/Mac/Modules/qt/Qtmodule.c b/Mac/Modules/qt/Qtmodule.c new file mode 100644 index 00000000000..c601292548c --- /dev/null +++ b/Mac/Modules/qt/Qtmodule.c @@ -0,0 +1,5951 @@ + +/* =========================== Module Qt ============================ */ + +#include "Python.h" + + + +#define SystemSevenOrLater 1 + +#include "macglue.h" +#include +#include +#include +#include + +extern PyObject *ResObj_New(Handle); +extern PyObject *ResObj_OptNew(Handle); +extern int ResObj_Convert(PyObject *, Handle *); + +extern PyObject *WinObj_New(WindowPtr); +extern int WinObj_Convert(PyObject *, WindowPtr *); +extern PyTypeObject Window_Type; +#define WinObj_Check(x) ((x)->ob_type == &Window_Type) + +extern PyObject *DlgObj_New(DialogPtr); +extern int DlgObj_Convert(PyObject *, DialogPtr *); +extern PyTypeObject Dialog_Type; +#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type) + +extern PyObject *MenuObj_New(MenuHandle); +extern int MenuObj_Convert(PyObject *, MenuHandle *); + +extern PyObject *CtlObj_New(ControlHandle); +extern int CtlObj_Convert(PyObject *, ControlHandle *); + +extern PyObject *GrafObj_New(GrafPtr); +extern int GrafObj_Convert(PyObject *, GrafPtr *); + +extern PyObject *BMObj_New(BitMapPtr); +extern int BMObj_Convert(PyObject *, BitMapPtr *); + +extern PyObject *WinObj_WhichWindow(WindowPtr); + +#include + +/* Exported by Cmmodule.c: */ +extern PyObject *CmpObj_New(Component); +extern int CmpObj_Convert(PyObject *, Component *); +extern PyObject *CmpInstObj_New(ComponentInstance); +extern int CmpInstObj_Convert(PyObject *, ComponentInstance *); + +/* Exported by Qdmodule.c: */ +extern PyObject *QdRGB_New(RGBColor *); +extern int QdRGB_Convert(PyObject *, RGBColor *); + +/* Our own, used before defined: */ +staticforward PyObject *TrackObj_New(Track); +staticforward int TrackObj_Convert(PyObject *, Track *); +staticforward PyObject *MovieObj_New(Movie); +staticforward int MovieObj_Convert(PyObject *, Movie *); + + + +static PyObject *Qt_Error; + +/* ---------------------- 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; +{ + 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 void TimeBaseObj_dealloc(self) + TimeBaseObject *self; +{ + DisposeTimeBase(self->ob_itself); + PyMem_DEL(self); +} + +static PyObject *TimeBaseObj_SetTimeBaseValue(_self, _args) + TimeBaseObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeValue t; + TimeScale s; + if (!PyArg_ParseTuple(_args, "ll", + &t, + &s)) + return NULL; + SetTimeBaseValue(_self->ob_itself, + t, + s); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TimeBaseObj_GetTimeBaseRate(_self, _args) + TimeBaseObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Fixed _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTimeBaseRate(_self->ob_itself); + _res = Py_BuildValue("O&", + PyMac_BuildFixed, _rv); + return _res; +} + +static PyObject *TimeBaseObj_SetTimeBaseRate(_self, _args) + TimeBaseObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Fixed r; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFixed, &r)) + return NULL; + SetTimeBaseRate(_self->ob_itself, + r); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TimeBaseObj_GetTimeBaseFlags(_self, _args) + TimeBaseObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + long _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTimeBaseFlags(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *TimeBaseObj_SetTimeBaseFlags(_self, _args) + TimeBaseObject *_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; + return _res; +} + +static PyObject *TimeBaseObj_GetTimeBaseMasterTimeBase(_self, _args) + TimeBaseObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeBase _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTimeBaseMasterTimeBase(_self->ob_itself); + _res = Py_BuildValue("O&", + TimeBaseObj_New, _rv); + return _res; +} + +static PyObject *TimeBaseObj_GetTimeBaseMasterClock(_self, _args) + TimeBaseObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentInstance _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTimeBaseMasterClock(_self->ob_itself); + _res = Py_BuildValue("O&", + CmpInstObj_New, _rv); + return _res; +} + +static PyObject *TimeBaseObj_GetTimeBaseEffectiveRate(_self, _args) + TimeBaseObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Fixed _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTimeBaseEffectiveRate(_self->ob_itself); + _res = Py_BuildValue("O&", + PyMac_BuildFixed, _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; +{ + return Py_FindMethodInChain(&TimeBaseObj_chain, (PyObject *)self, name); +} + +#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 data; + OSType udType; + long index; + if (!PyArg_ParseTuple(_args, "O&O&l", + ResObj_Convert, &data, + PyMac_GetOSType, &udType, + &index)) + return NULL; + _err = GetUserData(_self->ob_itself, + data, + udType, + index); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *UserDataObj_AddUserData(_self, _args) + UserDataObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + Handle data; + OSType udType; + if (!PyArg_ParseTuple(_args, "O&O&", + ResObj_Convert, &data, + PyMac_GetOSType, &udType)) + return NULL; + _err = AddUserData(_self->ob_itself, + data, + udType); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *UserDataObj_RemoveUserData(_self, _args) + UserDataObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + OSType udType; + long index; + if (!PyArg_ParseTuple(_args, "O&l", + PyMac_GetOSType, &udType, + &index)) + return NULL; + _err = RemoveUserData(_self->ob_itself, + udType, + index); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *UserDataObj_CountUserDataType(_self, _args) + UserDataObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short _rv; + OSType udType; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetOSType, &udType)) + return NULL; + _rv = CountUserDataType(_self->ob_itself, + udType); + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *UserDataObj_GetNextUserDataType(_self, _args) + UserDataObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + long _rv; + OSType udType; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetOSType, &udType)) + return NULL; + _rv = GetNextUserDataType(_self->ob_itself, + udType); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *UserDataObj_AddUserDataText(_self, _args) + UserDataObject *_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)) + return NULL; + _err = AddUserDataText(_self->ob_itself, + data, + udType, + index, + itlRegionTag); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *UserDataObj_GetUserDataText(_self, _args) + UserDataObject *_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)) + return NULL; + _err = GetUserDataText(_self->ob_itself, + data, + udType, + index, + itlRegionTag); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *UserDataObj_RemoveUserDataText(_self, _args) + UserDataObject *_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)) + return NULL; + _err = RemoveUserDataText(_self->ob_itself, + udType, + index, + itlRegionTag); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *UserDataObj_PutUserDataIntoHandle(_self, _args) + UserDataObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + Handle h; + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &h)) + return NULL; + _err = PutUserDataIntoHandle(_self->ob_itself, + h); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyMethodDef UserDataObj_methods[] = { + {"GetUserData", (PyCFunction)UserDataObj_GetUserData, 1, + "(Handle data, OSType udType, long index) -> None"}, + {"AddUserData", (PyCFunction)UserDataObj_AddUserData, 1, + "(Handle data, OSType udType) -> None"}, + {"RemoveUserData", (PyCFunction)UserDataObj_RemoveUserData, 1, + "(OSType udType, long index) -> None"}, + {"CountUserDataType", (PyCFunction)UserDataObj_CountUserDataType, 1, + "(OSType udType) -> (short _rv)"}, + {"GetNextUserDataType", (PyCFunction)UserDataObj_GetNextUserDataType, 1, + "(OSType udType) -> (long _rv)"}, + {"AddUserDataText", (PyCFunction)UserDataObj_AddUserDataText, 1, + "(Handle data, OSType udType, long index, short itlRegionTag) -> None"}, + {"GetUserDataText", (PyCFunction)UserDataObj_GetUserDataText, 1, + "(Handle data, OSType udType, long index, short itlRegionTag) -> None"}, + {"RemoveUserDataText", (PyCFunction)UserDataObj_RemoveUserDataText, 1, + "(OSType udType, long index, short itlRegionTag) -> None"}, + {"PutUserDataIntoHandle", (PyCFunction)UserDataObj_PutUserDataIntoHandle, 1, + "(Handle h) -> None"}, + {NULL, NULL, 0} +}; + +PyMethodChain UserDataObj_chain = { UserDataObj_methods, NULL }; + +static PyObject *UserDataObj_getattr(self, name) + UserDataObject *self; + char *name; +{ + return Py_FindMethodInChain(&UserDataObj_chain, (PyObject *)self, name); +} + +#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; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + TimeValue time; + TimeValue duration; + long flags; + if (!PyArg_ParseTuple(_args, "lll", + &time, + &duration, + &flags)) + return NULL; + _err = LoadMediaIntoRam(_self->ob_itself, + time, + duration, + flags); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MediaObj_GetMediaTrack(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Track _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMediaTrack(_self->ob_itself); + _res = Py_BuildValue("O&", + TrackObj_New, _rv); + return _res; +} + +static PyObject *MediaObj_GetMediaTimeScale(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeScale _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMediaTimeScale(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *MediaObj_SetMediaTimeScale(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeScale timeScale; + if (!PyArg_ParseTuple(_args, "l", + &timeScale)) + return NULL; + SetMediaTimeScale(_self->ob_itself, + timeScale); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MediaObj_GetMediaDuration(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeValue _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMediaDuration(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *MediaObj_GetMediaLanguage(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMediaLanguage(_self->ob_itself); + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *MediaObj_SetMediaLanguage(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short language; + if (!PyArg_ParseTuple(_args, "h", + &language)) + return NULL; + SetMediaLanguage(_self->ob_itself, + language); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MediaObj_GetMediaQuality(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMediaQuality(_self->ob_itself); + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *MediaObj_SetMediaQuality(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short quality; + if (!PyArg_ParseTuple(_args, "h", + &quality)) + return NULL; + SetMediaQuality(_self->ob_itself, + quality); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MediaObj_GetMediaHandlerDescription(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSType mediaType; + Str255 creatorName; + OSType creatorManufacturer; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetStr255, creatorName)) + return NULL; + GetMediaHandlerDescription(_self->ob_itself, + &mediaType, + creatorName, + &creatorManufacturer); + _res = Py_BuildValue("O&O&", + PyMac_BuildOSType, mediaType, + PyMac_BuildOSType, creatorManufacturer); + return _res; +} + +static PyObject *MediaObj_GetMediaUserData(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + UserData _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMediaUserData(_self->ob_itself); + _res = Py_BuildValue("O&", + UserDataObj_New, _rv); + return _res; +} + +static PyObject *MediaObj_GetMediaHandler(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + MediaHandler _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMediaHandler(_self->ob_itself); + _res = Py_BuildValue("O&", + CmpInstObj_New, _rv); + return _res; +} + +static PyObject *MediaObj_SetMediaHandler(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + MediaHandlerComponent mH; + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &mH)) + return NULL; + _err = SetMediaHandler(_self->ob_itself, + mH); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MediaObj_BeginMediaEdits(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + 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; +} + +static PyObject *MediaObj_EndMediaEdits(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + 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; +} + +static PyObject *MediaObj_SetMediaDefaultDataRefIndex(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + 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; +} + +static PyObject *MediaObj_GetMediaDataHandlerDescription(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short index; + OSType dhType; + Str255 creatorName; + OSType creatorManufacturer; + if (!PyArg_ParseTuple(_args, "hO&", + &index, + PyMac_GetStr255, creatorName)) + return NULL; + GetMediaDataHandlerDescription(_self->ob_itself, + index, + &dhType, + creatorName, + &creatorManufacturer); + _res = Py_BuildValue("O&O&", + PyMac_BuildOSType, dhType, + PyMac_BuildOSType, creatorManufacturer); + return _res; +} + +static PyObject *MediaObj_GetMediaDataHandler(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + DataHandler _rv; + short index; + if (!PyArg_ParseTuple(_args, "h", + &index)) + return NULL; + _rv = GetMediaDataHandler(_self->ob_itself, + index); + _res = Py_BuildValue("O&", + CmpInstObj_New, _rv); + return _res; +} + +static PyObject *MediaObj_SetMediaDataHandler(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + short index; + DataHandlerComponent dataHandler; + if (!PyArg_ParseTuple(_args, "hO&", + &index, + CmpObj_Convert, &dataHandler)) + return NULL; + _err = SetMediaDataHandler(_self->ob_itself, + index, + dataHandler); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MediaObj_GetMediaSampleDescriptionCount(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + long _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMediaSampleDescriptionCount(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *MediaObj_GetMediaSampleDescription(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + long index; + SampleDescriptionHandle descH; + if (!PyArg_ParseTuple(_args, "lO&", + &index, + ResObj_Convert, &descH)) + return NULL; + GetMediaSampleDescription(_self->ob_itself, + index, + descH); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MediaObj_SetMediaSampleDescription(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + long index; + SampleDescriptionHandle descH; + if (!PyArg_ParseTuple(_args, "lO&", + &index, + ResObj_Convert, &descH)) + return NULL; + _err = SetMediaSampleDescription(_self->ob_itself, + index, + descH); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MediaObj_GetMediaSampleCount(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + long _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMediaSampleCount(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *MediaObj_SampleNumToMediaTime(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + long logicalSampleNum; + TimeValue sampleTime; + TimeValue sampleDuration; + if (!PyArg_ParseTuple(_args, "l", + &logicalSampleNum)) + return NULL; + SampleNumToMediaTime(_self->ob_itself, + logicalSampleNum, + &sampleTime, + &sampleDuration); + _res = Py_BuildValue("ll", + sampleTime, + sampleDuration); + return _res; +} + +static PyObject *MediaObj_MediaTimeToSampleNum(_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 PyObject *MediaObj_AddMediaSample(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + Handle dataIn; + long inOffset; + unsigned long size; + TimeValue durationPerSample; + SampleDescriptionHandle sampleDescriptionH; + long numberOfSamples; + short sampleFlags; + TimeValue sampleTime; + if (!PyArg_ParseTuple(_args, "O&lllO&lh", + ResObj_Convert, &dataIn, + &inOffset, + &size, + &durationPerSample, + ResObj_Convert, &sampleDescriptionH, + &numberOfSamples, + &sampleFlags)) + return NULL; + _err = AddMediaSample(_self->ob_itself, + dataIn, + inOffset, + size, + durationPerSample, + sampleDescriptionH, + numberOfSamples, + sampleFlags, + &sampleTime); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + sampleTime); + return _res; +} + +static PyObject *MediaObj_AddMediaSampleReference(_self, _args) + MediaObject *_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)) + return NULL; + _err = AddMediaSampleReference(_self->ob_itself, + dataOffset, + size, + durationPerSample, + sampleDescriptionH, + numberOfSamples, + sampleFlags, + &sampleTime); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + sampleTime); + return _res; +} + +static PyObject *MediaObj_GetMediaSample(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + Handle dataOut; + long maxSizeToGrow; + long size; + TimeValue time; + TimeValue sampleTime; + TimeValue durationPerSample; + SampleDescriptionHandle sampleDescriptionH; + long sampleDescriptionIndex; + long maxNumberOfSamples; + long numberOfSamples; + short sampleFlags; + if (!PyArg_ParseTuple(_args, "O&llO&l", + ResObj_Convert, &dataOut, + &maxSizeToGrow, + &time, + ResObj_Convert, &sampleDescriptionH, + &maxNumberOfSamples)) + return NULL; + _err = GetMediaSample(_self->ob_itself, + dataOut, + maxSizeToGrow, + &size, + time, + &sampleTime, + &durationPerSample, + sampleDescriptionH, + &sampleDescriptionIndex, + maxNumberOfSamples, + &numberOfSamples, + &sampleFlags); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("lllllh", + size, + sampleTime, + durationPerSample, + sampleDescriptionIndex, + numberOfSamples, + sampleFlags); + return _res; +} + +static PyObject *MediaObj_GetMediaSampleReference(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + long dataOffset; + long size; + TimeValue time; + TimeValue sampleTime; + TimeValue durationPerSample; + SampleDescriptionHandle sampleDescriptionH; + long sampleDescriptionIndex; + long maxNumberOfSamples; + long numberOfSamples; + short sampleFlags; + 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; + 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); + return _res; +} + +static PyObject *MediaObj_GetMediaDataSize(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + long _rv; + TimeValue startTime; + TimeValue duration; + if (!PyArg_ParseTuple(_args, "ll", + &startTime, + &duration)) + return NULL; + _rv = GetMediaDataSize(_self->ob_itself, + startTime, + duration); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *MediaObj_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; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + short index; + Handle dataRef; + OSType dataRefType; + long dataRefAttributes; + if (!PyArg_ParseTuple(_args, "h", + &index)) + return NULL; + _err = GetMediaDataRef(_self->ob_itself, + index, + &dataRef, + &dataRefType, + &dataRefAttributes); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&O&l", + ResObj_New, dataRef, + PyMac_BuildOSType, dataRefType, + dataRefAttributes); + return _res; +} + +static PyObject *MediaObj_SetMediaDataRef(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + short index; + Handle dataRef; + OSType dataRefType; + if (!PyArg_ParseTuple(_args, "hO&O&", + &index, + ResObj_Convert, &dataRef, + PyMac_GetOSType, &dataRefType)) + return NULL; + _err = SetMediaDataRef(_self->ob_itself, + index, + dataRef, + dataRefType); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MediaObj_SetMediaDataRefAttributes(_self, _args) + MediaObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + short index; + long dataRefAttributes; + if (!PyArg_ParseTuple(_args, "hl", + &index, + &dataRefAttributes)) + return NULL; + _err = SetMediaDataRefAttributes(_self->ob_itself, + index, + dataRefAttributes); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MediaObj_AddMediaDataRef(_self, _args) + MediaObject *_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)) + return NULL; + _err = AddMediaDataRef(_self->ob_itself, + &index, + dataRef, + dataRefType); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + index); + return _res; +} + +static PyObject *MediaObj_GetMediaDataRefCount(_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"}, + {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; + OSErr _err; + TimeValue time; + TimeValue duration; + long flags; + if (!PyArg_ParseTuple(_args, "lll", + &time, + &duration, + &flags)) + return NULL; + _err = LoadTrackIntoRam(_self->ob_itself, + time, + duration, + flags); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_GetTrackPict(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + PicHandle _rv; + TimeValue time; + if (!PyArg_ParseTuple(_args, "l", + &time)) + return NULL; + _rv = GetTrackPict(_self->ob_itself, + time); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *TrackObj_GetTrackClipRgn(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + RgnHandle _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTrackClipRgn(_self->ob_itself); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *TrackObj_SetTrackClipRgn(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + RgnHandle theClip; + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &theClip)) + return NULL; + SetTrackClipRgn(_self->ob_itself, + theClip); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_GetTrackDisplayBoundsRgn(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + RgnHandle _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTrackDisplayBoundsRgn(_self->ob_itself); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *TrackObj_GetTrackMovieBoundsRgn(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + RgnHandle _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTrackMovieBoundsRgn(_self->ob_itself); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *TrackObj_GetTrackBoundsRgn(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + RgnHandle _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _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_GetTrackMovie(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Movie _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _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_GetTrackUsage(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + long _rv; + 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); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_GetTrackDuration(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeValue _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTrackDuration(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *TrackObj_GetTrackOffset(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeValue _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTrackOffset(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *TrackObj_SetTrackOffset(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeValue movieOffsetTime; + if (!PyArg_ParseTuple(_args, "l", + &movieOffsetTime)) + return NULL; + SetTrackOffset(_self->ob_itself, + movieOffsetTime); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_GetTrackLayer(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTrackLayer(_self->ob_itself); + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *TrackObj_SetTrackLayer(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short layer; + if (!PyArg_ParseTuple(_args, "h", + &layer)) + return NULL; + SetTrackLayer(_self->ob_itself, + layer); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_GetTrackAlternate(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Track _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTrackAlternate(_self->ob_itself); + _res = Py_BuildValue("O&", + TrackObj_New, _rv); + return _res; +} + +static PyObject *TrackObj_SetTrackAlternate(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Track alternateT; + if (!PyArg_ParseTuple(_args, "O&", + TrackObj_Convert, &alternateT)) + return NULL; + SetTrackAlternate(_self->ob_itself, + alternateT); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_GetTrackVolume(_self, _args) + TrackObject *_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)) + return NULL; + SetTrackVolume(_self->ob_itself, + volume); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_GetTrackDimensions(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Fixed width; + Fixed height; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + GetTrackDimensions(_self->ob_itself, + &width, + &height); + _res = Py_BuildValue("O&O&", + PyMac_BuildFixed, width, + PyMac_BuildFixed, height); + return _res; +} + +static PyObject *TrackObj_SetTrackDimensions(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Fixed width; + Fixed height; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetFixed, &width, + PyMac_GetFixed, &height)) + return NULL; + SetTrackDimensions(_self->ob_itself, + width, + height); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_GetTrackUserData(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + UserData _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTrackUserData(_self->ob_itself); + _res = Py_BuildValue("O&", + UserDataObj_New, _rv); + return _res; +} + +static PyObject *TrackObj_NewTrackMedia(_self, _args) + TrackObject *_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)) + return NULL; + _rv = NewTrackMedia(_self->ob_itself, + mediaType, + timeScale, + dataRef, + dataRefType); + _res = Py_BuildValue("O&", + MediaObj_New, _rv); + return _res; +} + +static PyObject *TrackObj_GetTrackMedia(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Media _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTrackMedia(_self->ob_itself); + _res = Py_BuildValue("O&", + MediaObj_New, _rv); + return _res; +} + +static PyObject *TrackObj_InsertMediaIntoTrack(_self, _args) + TrackObject *_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)) + return NULL; + _err = InsertMediaIntoTrack(_self->ob_itself, + trackStart, + mediaTime, + mediaDuration, + mediaRate); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_InsertTrackSegment(_self, _args) + TrackObject *_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; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + TimeValue dstIn; + TimeValue dstDuration; + if (!PyArg_ParseTuple(_args, "ll", + &dstIn, + &dstDuration)) + return NULL; + _err = InsertEmptyTrackSegment(_self->ob_itself, + dstIn, + dstDuration); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_DeleteTrackSegment(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + TimeValue startTime; + TimeValue duration; + if (!PyArg_ParseTuple(_args, "ll", + &startTime, + &duration)) + return NULL; + _err = DeleteTrackSegment(_self->ob_itself, + startTime, + duration); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_ScaleTrackSegment(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + TimeValue startTime; + TimeValue oldDuration; + TimeValue newDuration; + if (!PyArg_ParseTuple(_args, "lll", + &startTime, + &oldDuration, + &newDuration)) + return NULL; + _err = ScaleTrackSegment(_self->ob_itself, + startTime, + oldDuration, + newDuration); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_IsScrapMovie(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Component _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = IsScrapMovie(_self->ob_itself); + _res = Py_BuildValue("O&", + CmpObj_New, _rv); + return _res; +} + +static PyObject *TrackObj_CopyTrackSettings(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + Track dstTrack; + if (!PyArg_ParseTuple(_args, "O&", + TrackObj_Convert, &dstTrack)) + return NULL; + _err = CopyTrackSettings(_self->ob_itself, + dstTrack); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_AddEmptyTrackToMovie(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + 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; + _err = AddEmptyTrackToMovie(_self->ob_itself, + dstMovie, + dataRef, + dataRefType, + &dstTrack); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + TrackObj_New, dstTrack); + return _res; +} + +static PyObject *TrackObj_AddTrackReference(_self, _args) + TrackObject *_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)) + return NULL; + _err = AddTrackReference(_self->ob_itself, + refTrack, + refType, + &addedIndex); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + addedIndex); + return _res; +} + +static PyObject *TrackObj_DeleteTrackReference(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + OSType refType; + long index; + if (!PyArg_ParseTuple(_args, "O&l", + PyMac_GetOSType, &refType, + &index)) + return NULL; + _err = DeleteTrackReference(_self->ob_itself, + refType, + index); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_SetTrackReference(_self, _args) + TrackObject *_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)) + return NULL; + _err = SetTrackReference(_self->ob_itself, + refTrack, + refType, + index); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_GetTrackReference(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Track _rv; + OSType refType; + long index; + if (!PyArg_ParseTuple(_args, "O&l", + PyMac_GetOSType, &refType, + &index)) + return NULL; + _rv = GetTrackReference(_self->ob_itself, + refType, + index); + _res = Py_BuildValue("O&", + TrackObj_New, _rv); + return _res; +} + +static PyObject *TrackObj_GetNextTrackReferenceType(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSType _rv; + OSType refType; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetOSType, &refType)) + return NULL; + _rv = GetNextTrackReferenceType(_self->ob_itself, + refType); + _res = Py_BuildValue("O&", + PyMac_BuildOSType, _rv); + return _res; +} + +static PyObject *TrackObj_GetTrackReferenceCount(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + long _rv; + OSType refType; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetOSType, &refType)) + return NULL; + _rv = GetTrackReferenceCount(_self->ob_itself, + refType); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *TrackObj_GetTrackEditRate(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Fixed _rv; + TimeValue atTime; + if (!PyArg_ParseTuple(_args, "l", + &atTime)) + return NULL; + _rv = GetTrackEditRate(_self->ob_itself, + atTime); + _res = Py_BuildValue("O&", + PyMac_BuildFixed, _rv); + return _res; +} + +static PyObject *TrackObj_GetTrackDataSize(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + long _rv; + TimeValue startTime; + TimeValue duration; + if (!PyArg_ParseTuple(_args, "ll", + &startTime, + &duration)) + return NULL; + _rv = GetTrackDataSize(_self->ob_itself, + startTime, + duration); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *TrackObj_PtInTrack(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Boolean _rv; + Point pt; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetPoint, &pt)) + return NULL; + _rv = PtInTrack(_self->ob_itself, + pt); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *TrackObj_GetTrackNextInterestingTime(_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)) + return NULL; + GetTrackNextInterestingTime(_self->ob_itself, + interestingTimeFlags, + time, + rate, + &interestingTime, + &interestingDuration); + _res = Py_BuildValue("ll", + interestingTime, + interestingDuration); + return _res; +} + +static PyObject *TrackObj_GetTrackSegmentDisplayBoundsRgn(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + RgnHandle _rv; + TimeValue time; + TimeValue duration; + if (!PyArg_ParseTuple(_args, "ll", + &time, + &duration)) + return NULL; + _rv = GetTrackSegmentDisplayBoundsRgn(_self->ob_itself, + time, + duration); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *TrackObj_GetTrackStatus(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetTrackStatus(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *TrackObj_SetTrackLoadSettings(_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)) + return NULL; + SetTrackLoadSettings(_self->ob_itself, + preloadTime, + preloadDuration, + preloadFlags, + defaultHints); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *TrackObj_GetTrackLoadSettings(_self, _args) + TrackObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeValue preloadTime; + TimeValue preloadDuration; + long preloadFlags; + long defaultHints; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + GetTrackLoadSettings(_self->ob_itself, + &preloadTime, + &preloadDuration, + &preloadFlags, + &defaultHints); + _res = Py_BuildValue("llll", + preloadTime, + preloadDuration, + preloadFlags, + defaultHints); + return _res; +} + +static PyMethodDef TrackObj_methods[] = { + {"LoadTrackIntoRam", (PyCFunction)TrackObj_LoadTrackIntoRam, 1, + "(TimeValue time, TimeValue duration, long flags) -> None"}, + {"GetTrackPict", (PyCFunction)TrackObj_GetTrackPict, 1, + "(TimeValue time) -> (PicHandle _rv)"}, + {"GetTrackClipRgn", (PyCFunction)TrackObj_GetTrackClipRgn, 1, + "() -> (RgnHandle _rv)"}, + {"SetTrackClipRgn", (PyCFunction)TrackObj_SetTrackClipRgn, 1, + "(RgnHandle theClip) -> None"}, + {"GetTrackDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackDisplayBoundsRgn, 1, + "() -> (RgnHandle _rv)"}, + {"GetTrackMovieBoundsRgn", (PyCFunction)TrackObj_GetTrackMovieBoundsRgn, 1, + "() -> (RgnHandle _rv)"}, + {"GetTrackBoundsRgn", (PyCFunction)TrackObj_GetTrackBoundsRgn, 1, + "() -> (RgnHandle _rv)"}, + {"GetTrackMatte", (PyCFunction)TrackObj_GetTrackMatte, 1, + "() -> (PixMapHandle _rv)"}, + {"SetTrackMatte", (PyCFunction)TrackObj_SetTrackMatte, 1, + "(PixMapHandle theMatte) -> None"}, + {"GetTrackID", (PyCFunction)TrackObj_GetTrackID, 1, + "() -> (long _rv)"}, + {"GetTrackMovie", (PyCFunction)TrackObj_GetTrackMovie, 1, + "() -> (Movie _rv)"}, + {"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; + long maxMilliSecToUse; + if (!PyArg_ParseTuple(_args, "l", + &maxMilliSecToUse)) + return NULL; + MoviesTask(_self->ob_itself, + maxMilliSecToUse); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_PrerollMovie(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + TimeValue time; + Fixed Rate; + if (!PyArg_ParseTuple(_args, "lO&", + &time, + PyMac_GetFixed, &Rate)) + return NULL; + _err = PrerollMovie(_self->ob_itself, + time, + Rate); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_LoadMovieIntoRam(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + TimeValue time; + TimeValue duration; + long flags; + if (!PyArg_ParseTuple(_args, "lll", + &time, + &duration, + &flags)) + return NULL; + _err = LoadMovieIntoRam(_self->ob_itself, + time, + duration, + flags); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_SetMovieActive(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Boolean active; + if (!PyArg_ParseTuple(_args, "b", + &active)) + return NULL; + SetMovieActive(_self->ob_itself, + active); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMovieActive(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Boolean _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMovieActive(_self->ob_itself); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *MovieObj_StartMovie(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + StartMovie(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_StopMovie(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + StopMovie(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GoToBeginningOfMovie(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + GoToBeginningOfMovie(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GoToEndOfMovie(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + GoToEndOfMovie(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_IsMovieDone(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Boolean _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = IsMovieDone(_self->ob_itself); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *MovieObj_GetMoviePreviewMode(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Boolean _rv; + 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; + return _res; +} + +static PyObject *MovieObj_ShowMoviePoster(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + 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&", + TimeBaseObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_GetNextTrackForCompositing(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Track _rv; + Track theTrack; + if (!PyArg_ParseTuple(_args, "O&", + TrackObj_Convert, &theTrack)) + return NULL; + _rv = GetNextTrackForCompositing(_self->ob_itself, + theTrack); + _res = Py_BuildValue("O&", + TrackObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_GetPrevTrackForCompositing(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Track _rv; + Track theTrack; + if (!PyArg_ParseTuple(_args, "O&", + TrackObj_Convert, &theTrack)) + return NULL; + _rv = GetPrevTrackForCompositing(_self->ob_itself, + theTrack); + _res = Py_BuildValue("O&", + TrackObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_GetMoviePict(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + PicHandle _rv; + TimeValue time; + if (!PyArg_ParseTuple(_args, "l", + &time)) + return NULL; + _rv = GetMoviePict(_self->ob_itself, + time); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_GetMoviePosterPict(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + PicHandle _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMoviePosterPict(_self->ob_itself); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_UpdateMovie(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = UpdateMovie(_self->ob_itself); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMovieBox(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Rect boxRect; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + GetMovieBox(_self->ob_itself, + &boxRect); + _res = Py_BuildValue("O&", + PyMac_BuildRect, &boxRect); + return _res; +} + +static PyObject *MovieObj_SetMovieBox(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Rect boxRect; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetRect, &boxRect)) + return NULL; + SetMovieBox(_self->ob_itself, + &boxRect); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMovieDisplayClipRgn(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + RgnHandle _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMovieDisplayClipRgn(_self->ob_itself); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_SetMovieDisplayClipRgn(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + RgnHandle theClip; + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &theClip)) + return NULL; + SetMovieDisplayClipRgn(_self->ob_itself, + theClip); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMovieClipRgn(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + RgnHandle _rv; + if (!PyArg_ParseTuple(_args, "")) + 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); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_GetMovieBoundsRgn(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + RgnHandle _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMovieBoundsRgn(_self->ob_itself); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_PutMovieIntoHandle(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + Handle publicMovie; + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &publicMovie)) + return NULL; + _err = PutMovieIntoHandle(_self->ob_itself, + publicMovie); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_PutMovieIntoDataFork(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + short fRefNum; + long offset; + long maxSize; + if (!PyArg_ParseTuple(_args, "hll", + &fRefNum, + &offset, + &maxSize)) + return NULL; + _err = PutMovieIntoDataFork(_self->ob_itself, + fRefNum, + offset, + maxSize); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMovieTimeScale(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeScale _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMovieTimeScale(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *MovieObj_SetMovieTimeScale(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeScale timeScale; + if (!PyArg_ParseTuple(_args, "l", + &timeScale)) + return NULL; + SetMovieTimeScale(_self->ob_itself, + timeScale); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMovieDuration(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeValue _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMovieDuration(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *MovieObj_GetMovieRate(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Fixed _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMovieRate(_self->ob_itself); + _res = Py_BuildValue("O&", + PyMac_BuildFixed, _rv); + return _res; +} + +static PyObject *MovieObj_SetMovieRate(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Fixed rate; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFixed, &rate)) + return NULL; + SetMovieRate(_self->ob_itself, + rate); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMoviePreferredRate(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Fixed _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMoviePreferredRate(_self->ob_itself); + _res = Py_BuildValue("O&", + PyMac_BuildFixed, _rv); + return _res; +} + +static PyObject *MovieObj_SetMoviePreferredRate(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Fixed rate; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFixed, &rate)) + return NULL; + SetMoviePreferredRate(_self->ob_itself, + rate); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMoviePreferredVolume(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMoviePreferredVolume(_self->ob_itself); + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *MovieObj_SetMoviePreferredVolume(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short volume; + if (!PyArg_ParseTuple(_args, "h", + &volume)) + return NULL; + SetMoviePreferredVolume(_self->ob_itself, + volume); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMovieVolume(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + short _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _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_GetMoviePreviewTime(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeValue previewTime; + TimeValue previewDuration; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + GetMoviePreviewTime(_self->ob_itself, + &previewTime, + &previewDuration); + _res = Py_BuildValue("ll", + previewTime, + previewDuration); + return _res; +} + +static PyObject *MovieObj_SetMoviePreviewTime(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeValue previewTime; + TimeValue previewDuration; + if (!PyArg_ParseTuple(_args, "ll", + &previewTime, + &previewDuration)) + return NULL; + SetMoviePreviewTime(_self->ob_itself, + previewTime, + previewDuration); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMoviePosterTime(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeValue _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMoviePosterTime(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *MovieObj_SetMoviePosterTime(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeValue posterTime; + if (!PyArg_ParseTuple(_args, "l", + &posterTime)) + return NULL; + SetMoviePosterTime(_self->ob_itself, + posterTime); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMovieSelection(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeValue selectionTime; + TimeValue selectionDuration; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + GetMovieSelection(_self->ob_itself, + &selectionTime, + &selectionDuration); + _res = Py_BuildValue("ll", + selectionTime, + selectionDuration); + return _res; +} + +static PyObject *MovieObj_SetMovieSelection(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeValue selectionTime; + TimeValue selectionDuration; + if (!PyArg_ParseTuple(_args, "ll", + &selectionTime, + &selectionDuration)) + return NULL; + SetMovieSelection(_self->ob_itself, + selectionTime, + selectionDuration); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_SetMovieActiveSegment(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + 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_GetMovieActiveSegment(_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); + 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_GetMovieUserData(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + UserData _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMovieUserData(_self->ob_itself); + _res = Py_BuildValue("O&", + UserDataObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_GetMovieTrackCount(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + long _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMovieTrackCount(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *MovieObj_GetMovieTrack(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Track _rv; + long trackID; + if (!PyArg_ParseTuple(_args, "l", + &trackID)) + return NULL; + _rv = GetMovieTrack(_self->ob_itself, + trackID); + _res = Py_BuildValue("O&", + TrackObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_GetMovieIndTrack(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Track _rv; + long index; + if (!PyArg_ParseTuple(_args, "l", + &index)) + return NULL; + _rv = GetMovieIndTrack(_self->ob_itself, + index); + _res = Py_BuildValue("O&", + TrackObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_GetMovieIndTrackType(_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_InsertEmptyMovieSegment(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + TimeValue dstIn; + TimeValue dstDuration; + if (!PyArg_ParseTuple(_args, "ll", + &dstIn, + &dstDuration)) + return NULL; + _err = InsertEmptyMovieSegment(_self->ob_itself, + dstIn, + dstDuration); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_DeleteMovieSegment(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + TimeValue startTime; + TimeValue duration; + if (!PyArg_ParseTuple(_args, "ll", + &startTime, + &duration)) + return NULL; + _err = DeleteMovieSegment(_self->ob_itself, + startTime, + duration); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_ScaleMovieSegment(_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)) + return NULL; + _err = ScaleMovieSegment(_self->ob_itself, + startTime, + oldDuration, + newDuration); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_CutMovieSelection(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Movie _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CutMovieSelection(_self->ob_itself); + _res = Py_BuildValue("O&", + MovieObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_CopyMovieSelection(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Movie _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CopyMovieSelection(_self->ob_itself); + _res = Py_BuildValue("O&", + MovieObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_PasteMovieSelection(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Movie src; + if (!PyArg_ParseTuple(_args, "O&", + MovieObj_Convert, &src)) + return NULL; + PasteMovieSelection(_self->ob_itself, + src); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_AddMovieSelection(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Movie src; + if (!PyArg_ParseTuple(_args, "O&", + MovieObj_Convert, &src)) + return NULL; + AddMovieSelection(_self->ob_itself, + src); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_ClearMovieSelection(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + ClearMovieSelection(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_PutMovieIntoTypedHandle(_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)) + return NULL; + _err = PutMovieIntoTypedHandle(_self->ob_itself, + targetTrack, + handleType, + publicMovie, + start, + dur, + flags, + userComp); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_CopyMovieSettings(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + Movie dstMovie; + if (!PyArg_ParseTuple(_args, "O&", + MovieObj_Convert, &dstMovie)) + return NULL; + _err = CopyMovieSettings(_self->ob_itself, + dstMovie); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_ConvertMovieToFile(_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)) + return NULL; + _err = ConvertMovieToFile(_self->ob_itself, + onlyTrack, + &outputFile, + fileType, + creator, + scriptTag, + &resID, + flags, + userComp); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + resID); + return _res; +} + +static PyObject *MovieObj_GetMovieDataSize(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + long _rv; + TimeValue startTime; + TimeValue duration; + if (!PyArg_ParseTuple(_args, "ll", + &startTime, + &duration)) + return NULL; + _rv = GetMovieDataSize(_self->ob_itself, + startTime, + duration); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *MovieObj_PtInMovie(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Boolean _rv; + Point pt; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetPoint, &pt)) + return NULL; + _rv = PtInMovie(_self->ob_itself, + pt); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *MovieObj_SetMovieLanguage(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + long language; + if (!PyArg_ParseTuple(_args, "l", + &language)) + return NULL; + SetMovieLanguage(_self->ob_itself, + language); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMovieNextInterestingTime(_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, + PyMac_GetFixed, &rate)) + return NULL; + GetMovieNextInterestingTime(_self->ob_itself, + interestingTimeFlags, + numMediaTypes, + &whichMediaTypes, + time, + rate, + &interestingTime, + &interestingDuration); + _res = Py_BuildValue("ll", + interestingTime, + interestingDuration); + return _res; +} + +static PyObject *MovieObj_AddMovieResource(_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)) + return NULL; + _err = AddMovieResource(_self->ob_itself, + resRefNum, + &resId, + resName); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + resId); + return _res; +} + +static PyObject *MovieObj_UpdateMovieResource(_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)) + return NULL; + _err = UpdateMovieResource(_self->ob_itself, + resRefNum, + resId, + resName); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_HasMovieChanged(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Boolean _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = HasMovieChanged(_self->ob_itself); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *MovieObj_ClearMovieChanged(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + ClearMovieChanged(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_SetMovieDefaultDataRef(_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)) + return NULL; + _err = SetMovieDefaultDataRef(_self->ob_itself, + dataRef, + dataRefType); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMovieDefaultDataRef(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + Handle dataRef; + OSType dataRefType; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = GetMovieDefaultDataRef(_self->ob_itself, + &dataRef, + &dataRefType); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&O&", + ResObj_New, dataRef, + PyMac_BuildOSType, dataRefType); + return _res; +} + +static PyObject *MovieObj_SetMovieColorTable(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + CTabHandle ctab; + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &ctab)) + return NULL; + _err = SetMovieColorTable(_self->ob_itself, + ctab); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMovieColorTable(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + CTabHandle ctab; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = GetMovieColorTable(_self->ob_itself, + &ctab); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, ctab); + return _res; +} + +static PyObject *MovieObj_FlattenMovie(_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)) + return NULL; + FlattenMovie(_self->ob_itself, + movieFlattenFlags, + &theFile, + creator, + scriptTag, + createMovieFileFlags, + &resId, + resName); + _res = Py_BuildValue("h", + resId); + return _res; +} + +static PyObject *MovieObj_FlattenMovieData(_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)) + return NULL; + _rv = FlattenMovieData(_self->ob_itself, + movieFlattenFlags, + &theFile, + creator, + scriptTag, + createMovieFileFlags); + _res = Py_BuildValue("O&", + MovieObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_MovieSearchText(_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)) + 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&", + PyMac_GetRect, &boxRect)) + return NULL; + SetPosterBox(_self->ob_itself, + &boxRect); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_GetMovieSegmentDisplayBoundsRgn(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + RgnHandle _rv; + TimeValue time; + TimeValue duration; + if (!PyArg_ParseTuple(_args, "ll", + &time, + &duration)) + return NULL; + _rv = GetMovieSegmentDisplayBoundsRgn(_self->ob_itself, + time, + duration); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_GetMovieStatus(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + Track firstProblemTrack; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMovieStatus(_self->ob_itself, + &firstProblemTrack); + _res = Py_BuildValue("lO&", + _rv, + TrackObj_New, firstProblemTrack); + return _res; +} + +static PyObject *MovieObj_NewMovieController(_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)) + return NULL; + _rv = NewMovieController(_self->ob_itself, + &movieRect, + someFlags); + _res = Py_BuildValue("O&", + CmpInstObj_New, _rv); + return _res; +} + +static PyObject *MovieObj_PutMovieOnScrap(_self, _args) + MovieObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + long movieScrapFlags; + if (!PyArg_ParseTuple(_args, "l", + &movieScrapFlags)) + return NULL; + _err = PutMovieOnScrap(_self->ob_itself, + movieScrapFlags); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *MovieObj_SetMoviePlayHints(_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) -> (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; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = EnterMovies(); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_ExitMovies(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + ExitMovies(); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_GetMoviesError(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = GetMoviesError(); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_ClearMoviesStickyError(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + ClearMoviesStickyError(); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_GetMoviesStickyError(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = GetMoviesStickyError(); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_DisposeMatte(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + PixMapHandle theMatte; + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &theMatte)) + return NULL; + DisposeMatte(theMatte); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_NewMovie(_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; + 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)) + return NULL; + _rv = GetDataHandler(dataRef, + dataHandlerSubType, + flags); + _res = Py_BuildValue("O&", + CmpObj_New, _rv); + return _res; +} + +static PyObject *Qt_PasteHandleIntoMovie(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + Handle h; + OSType handleType; + Movie theMovie; + long flags; + ComponentInstance userComp; + if (!PyArg_ParseTuple(_args, "O&O&O&lO&", + ResObj_Convert, &h, + PyMac_GetOSType, &handleType, + MovieObj_Convert, &theMovie, + &flags, + CmpInstObj_Convert, &userComp)) + return NULL; + _err = PasteHandleIntoMovie(h, + handleType, + theMovie, + flags, + userComp); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_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; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + Handle h; + UserData theUserData; + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &h)) + return NULL; + _err = NewUserDataFromHandle(h, + &theUserData); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + UserDataObj_New, theUserData); + return _res; +} + +static PyObject *Qt_CreateMovieFile(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + 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; + _err = CreateMovieFile(&fileSpec, + creator, + scriptTag, + createMovieFileFlags, + &resRefNum, + &newmovie); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("hO&", + resRefNum, + MovieObj_New, newmovie); + return _res; +} + +static PyObject *Qt_OpenMovieFile(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec fileSpec; + short resRefNum; + SInt8 permission; + if (!PyArg_ParseTuple(_args, "O&b", + PyMac_GetFSSpec, &fileSpec, + &permission)) + return NULL; + _err = OpenMovieFile(&fileSpec, + &resRefNum, + permission); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + resRefNum); + return _res; +} + +static PyObject *Qt_CloseMovieFile(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + short resRefNum; + if (!PyArg_ParseTuple(_args, "h", + &resRefNum)) + return NULL; + _err = CloseMovieFile(resRefNum); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_DeleteMovieFile(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec fileSpec; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSSpec, &fileSpec)) + return NULL; + _err = DeleteMovieFile(&fileSpec); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_NewMovieFromFile(_self, _args) + PyObject *_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)) + 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); + return _res; +} + +static PyObject *Qt_NewMovieFromDataFork(_self, _args) + PyObject *_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)) + return NULL; + _err = NewMovieFromDataFork(&theMovie, + fRefNum, + fileOffset, + newMovieFlags, + &dataRefWasChanged); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&b", + MovieObj_New, theMovie, + dataRefWasChanged); + return _res; +} + +static PyObject *Qt_RemoveMovieResource(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + OSErr _err; + short resRefNum; + short resId; + if (!PyArg_ParseTuple(_args, "hh", + &resRefNum, + &resId)) + return NULL; + _err = RemoveMovieResource(resRefNum, + resId); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_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; + 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)) + return NULL; + _rv = SetVideoMediaGraphicsMode(mh, + graphicsMode, + &opColor); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GetSoundMediaBalance(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + HandlerError _rv; + MediaHandler mh; + short balance; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mh)) + return NULL; + _rv = GetSoundMediaBalance(mh, + &balance); + _res = Py_BuildValue("lh", + _rv, + balance); + return _res; +} + +static PyObject *Qt_SetSoundMediaBalance(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + HandlerError _rv; + MediaHandler mh; + short balance; + if (!PyArg_ParseTuple(_args, "O&h", + CmpInstObj_Convert, &mh, + &balance)) + return NULL; + _rv = SetSoundMediaBalance(mh, + balance); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_FindNextText(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + MediaHandler mh; + Ptr text; + long size; + short findFlags; + TimeValue startTime; + TimeValue foundTime; + TimeValue foundDuration; + long offset; + if (!PyArg_ParseTuple(_args, "O&slhl", + CmpInstObj_Convert, &mh, + &text, + &size, + &findFlags, + &startTime)) + return NULL; + _rv = FindNextText(mh, + text, + size, + findFlags, + startTime, + &foundTime, + &foundDuration, + &offset); + _res = Py_BuildValue("llll", + _rv, + foundTime, + foundDuration, + offset); + return _res; +} + +static PyObject *Qt_DisposeMovieController(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentInstance mc; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mc)) + return NULL; + DisposeMovieController(mc); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_NewMovieFromScrap(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Movie _rv; + long newMovieFlags; + if (!PyArg_ParseTuple(_args, "l", + &newMovieFlags)) + return NULL; + _rv = NewMovieFromScrap(newMovieFlags); + _res = Py_BuildValue("O&", + MovieObj_New, _rv); + return _res; +} + +static PyObject *Qt_MCSetMovie(_self, _args) + PyObject *_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)) + return NULL; + _rv = MCSetMovie(mc, + theMovie, + movieWindow, + where); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCGetIndMovie(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Movie _rv; + MovieController mc; + short index; + if (!PyArg_ParseTuple(_args, "O&h", + CmpInstObj_Convert, &mc, + &index)) + return NULL; + _rv = MCGetIndMovie(mc, + index); + _res = Py_BuildValue("O&", + MovieObj_New, _rv); + return _res; +} + +static PyObject *Qt_MCRemoveMovie(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + MovieController mc; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mc)) + return NULL; + _rv = MCRemoveMovie(mc); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCIsPlayerEvent(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + MovieController mc; + EventRecord e; + if (!PyArg_ParseTuple(_args, "O&O&", + CmpInstObj_Convert, &mc, + PyMac_GetEventRecord, &e)) + return NULL; + _rv = MCIsPlayerEvent(mc, + &e); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCSetControllerAttached(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + MovieController mc; + Boolean attach; + if (!PyArg_ParseTuple(_args, "O&b", + CmpInstObj_Convert, &mc, + &attach)) + return NULL; + _rv = MCSetControllerAttached(mc, + attach); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCIsControllerAttached(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + MovieController mc; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mc)) + return NULL; + _rv = MCIsControllerAttached(mc); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCSetVisible(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + MovieController mc; + Boolean visible; + if (!PyArg_ParseTuple(_args, "O&b", + CmpInstObj_Convert, &mc, + &visible)) + return NULL; + _rv = MCSetVisible(mc, + visible); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCGetVisible(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + MovieController mc; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mc)) + return NULL; + _rv = MCGetVisible(mc); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCGetControllerBoundsRect(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + MovieController mc; + Rect bounds; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mc)) + return NULL; + _rv = MCGetControllerBoundsRect(mc, + &bounds); + _res = Py_BuildValue("lO&", + _rv, + PyMac_BuildRect, &bounds); + return _res; +} + +static PyObject *Qt_MCSetControllerBoundsRect(_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)) + return NULL; + _rv = MCSetControllerBoundsRect(mc, + &bounds); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCGetControllerBoundsRgn(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + RgnHandle _rv; + MovieController mc; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mc)) + return NULL; + _rv = MCGetControllerBoundsRgn(mc); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *Qt_MCGetWindowRgn(_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)) + return NULL; + _rv = MCGetWindowRgn(mc, + w); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *Qt_MCMovieChanged(_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)) + return NULL; + _rv = MCMovieChanged(mc, + m); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCSetDuration(_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)) + return NULL; + _rv = MCSetDuration(mc, + duration); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCGetCurrentTime(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + TimeValue _rv; + MovieController mc; + TimeScale scale; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mc)) + return NULL; + _rv = MCGetCurrentTime(mc, + &scale); + _res = Py_BuildValue("ll", + _rv, + scale); + return _res; +} + +static PyObject *Qt_MCNewAttachedController(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + MovieController mc; + Movie theMovie; + WindowPtr w; + Point where; + if (!PyArg_ParseTuple(_args, "O&O&O&O&", + CmpInstObj_Convert, &mc, + MovieObj_Convert, &theMovie, + WinObj_Convert, &w, + PyMac_GetPoint, &where)) + return NULL; + _rv = MCNewAttachedController(mc, + theMovie, + w, + where); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCDraw(_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)) + return NULL; + _rv = MCDraw(mc, + w); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCActivate(_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)) + return NULL; + _rv = MCActivate(mc, + w, + activate); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCIdle(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + MovieController mc; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mc)) + return NULL; + _rv = MCIdle(mc); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCKey(_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)) + return NULL; + _rv = MCKey(mc, + key, + modifiers); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCClick(_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)) + return NULL; + _rv = MCClick(mc, + w, + where, + when, + modifiers); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCEnableEditing(_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)) + return NULL; + _rv = MCEnableEditing(mc, + enabled); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCIsEditingEnabled(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + long _rv; + MovieController mc; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mc)) + return NULL; + _rv = MCIsEditingEnabled(mc); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCCopy(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Movie _rv; + MovieController mc; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mc)) + return NULL; + _rv = MCCopy(mc); + _res = Py_BuildValue("O&", + MovieObj_New, _rv); + return _res; +} + +static PyObject *Qt_MCCut(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Movie _rv; + MovieController mc; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mc)) + return NULL; + _rv = MCCut(mc); + _res = Py_BuildValue("O&", + MovieObj_New, _rv); + return _res; +} + +static PyObject *Qt_MCPaste(_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)) + return NULL; + _rv = MCPaste(mc, + srcMovie); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCClear(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + MovieController mc; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mc)) + return NULL; + _rv = MCClear(mc); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCUndo(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + MovieController mc; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mc)) + return NULL; + _rv = MCUndo(mc); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCPositionController(_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)) + return NULL; + _rv = MCPositionController(mc, + &movieRect, + &controllerRect, + someFlags); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCGetControllerInfo(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + ComponentResult _rv; + MovieController mc; + long someFlags; + if (!PyArg_ParseTuple(_args, "O&", + CmpInstObj_Convert, &mc)) + return NULL; + _rv = MCGetControllerInfo(mc, + &someFlags); + _res = Py_BuildValue("ll", + _rv, + someFlags); + return _res; +} + +static PyObject *Qt_MCSetClip(_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)) + return NULL; + _rv = MCSetClip(mc, + theClip, + movieClip); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCGetClip(_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)) + return NULL; + _rv = MCGetClip(mc, + &theClip, + &movieClip); + _res = Py_BuildValue("lO&O&", + _rv, + ResObj_New, theClip, + ResObj_New, movieClip); + return _res; +} + +static PyObject *Qt_MCDrawBadge(_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)) + return NULL; + _rv = MCDrawBadge(mc, + movieRgn, + &badgeRgn); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, badgeRgn); + return _res; +} + +static PyObject *Qt_MCSetUpEditMenu(_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)) + return NULL; + _rv = MCSetUpEditMenu(mc, + modifiers, + mh); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_MCGetMenuString(_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)) + return NULL; + _rv = MCGetMenuString(mc, + modifiers, + item, + aString); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_NewTimeBase(_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); + return _res; +} + +static PyMethodDef Qt_methods[] = { + {"EnterMovies", (PyCFunction)Qt_EnterMovies, 1, + "() -> None"}, + {"ExitMovies", (PyCFunction)Qt_ExitMovies, 1, + "() -> None"}, + {"GetMoviesError", (PyCFunction)Qt_GetMoviesError, 1, + "() -> None"}, + {"ClearMoviesStickyError", (PyCFunction)Qt_ClearMoviesStickyError, 1, + "() -> None"}, + {"GetMoviesStickyError", (PyCFunction)Qt_GetMoviesStickyError, 1, + "() -> None"}, + {"DisposeMatte", (PyCFunction)Qt_DisposeMatte, 1, + "(PixMapHandle theMatte) -> None"}, + {"NewMovie", (PyCFunction)Qt_NewMovie, 1, + "(long flags) -> (Movie _rv)"}, + {"GetDataHandler", (PyCFunction)Qt_GetDataHandler, 1, + "(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)"}, + {"PasteHandleIntoMovie", (PyCFunction)Qt_PasteHandleIntoMovie, 1, + "(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None"}, + {"TrackTimeToMediaTime", (PyCFunction)Qt_TrackTimeToMediaTime, 1, + "(TimeValue value, Track theTrack) -> (TimeValue _rv)"}, + {"NewUserData", (PyCFunction)Qt_NewUserData, 1, + "() -> (UserData theUserData)"}, + {"NewUserDataFromHandle", (PyCFunction)Qt_NewUserDataFromHandle, 1, + "(Handle h) -> (UserData theUserData)"}, + {"CreateMovieFile", (PyCFunction)Qt_CreateMovieFile, 1, + "(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (short resRefNum, Movie newmovie)"}, + {"OpenMovieFile", (PyCFunction)Qt_OpenMovieFile, 1, + "(FSSpec fileSpec, SInt8 permission) -> (short resRefNum)"}, + {"CloseMovieFile", (PyCFunction)Qt_CloseMovieFile, 1, + "(short resRefNum) -> None"}, + {"DeleteMovieFile", (PyCFunction)Qt_DeleteMovieFile, 1, + "(FSSpec fileSpec) -> None"}, + {"NewMovieFromFile", (PyCFunction)Qt_NewMovieFromFile, 1, + "(short resRefNum, StringPtr resName, short newMovieFlags) -> (Movie theMovie, short resId, Boolean dataRefWasChanged)"}, + {"NewMovieFromHandle", (PyCFunction)Qt_NewMovieFromHandle, 1, + "(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"}, + {"NewMovieFromDataFork", (PyCFunction)Qt_NewMovieFromDataFork, 1, + "(short fRefNum, long fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"}, + {"RemoveMovieResource", (PyCFunction)Qt_RemoveMovieResource, 1, + "(short resRefNum, short resId) -> None"}, + {"GetVideoMediaGraphicsMode", (PyCFunction)Qt_GetVideoMediaGraphicsMode, 1, + "(MediaHandler mh) -> (HandlerError _rv, long graphicsMode, RGBColor opColor)"}, + {"SetVideoMediaGraphicsMode", (PyCFunction)Qt_SetVideoMediaGraphicsMode, 1, + "(MediaHandler mh, long graphicsMode, RGBColor opColor) -> (HandlerError _rv)"}, + {"GetSoundMediaBalance", (PyCFunction)Qt_GetSoundMediaBalance, 1, + "(MediaHandler mh) -> (HandlerError _rv, short balance)"}, + {"SetSoundMediaBalance", (PyCFunction)Qt_SetSoundMediaBalance, 1, + "(MediaHandler mh, short balance) -> (HandlerError _rv)"}, + {"FindNextText", (PyCFunction)Qt_FindNextText, 1, + "(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)"}, + {"DisposeMovieController", (PyCFunction)Qt_DisposeMovieController, 1, + "(ComponentInstance mc) -> None"}, + {"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1, + "(long newMovieFlags) -> (Movie _rv)"}, + {"MCSetMovie", (PyCFunction)Qt_MCSetMovie, 1, + "(MovieController mc, Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)"}, + {"MCGetIndMovie", (PyCFunction)Qt_MCGetIndMovie, 1, + "(MovieController mc, short index) -> (Movie _rv)"}, + {"MCRemoveMovie", (PyCFunction)Qt_MCRemoveMovie, 1, + "(MovieController mc) -> (ComponentResult _rv)"}, + {"MCIsPlayerEvent", (PyCFunction)Qt_MCIsPlayerEvent, 1, + "(MovieController mc, EventRecord e) -> (ComponentResult _rv)"}, + {"MCSetControllerAttached", (PyCFunction)Qt_MCSetControllerAttached, 1, + "(MovieController mc, Boolean attach) -> (ComponentResult _rv)"}, + {"MCIsControllerAttached", (PyCFunction)Qt_MCIsControllerAttached, 1, + "(MovieController mc) -> (ComponentResult _rv)"}, + {"MCSetVisible", (PyCFunction)Qt_MCSetVisible, 1, + "(MovieController mc, Boolean visible) -> (ComponentResult _rv)"}, + {"MCGetVisible", (PyCFunction)Qt_MCGetVisible, 1, + "(MovieController mc) -> (ComponentResult _rv)"}, + {"MCGetControllerBoundsRect", (PyCFunction)Qt_MCGetControllerBoundsRect, 1, + "(MovieController mc) -> (ComponentResult _rv, Rect bounds)"}, + {"MCSetControllerBoundsRect", (PyCFunction)Qt_MCSetControllerBoundsRect, 1, + "(MovieController mc, Rect bounds) -> (ComponentResult _rv)"}, + {"MCGetControllerBoundsRgn", (PyCFunction)Qt_MCGetControllerBoundsRgn, 1, + "(MovieController mc) -> (RgnHandle _rv)"}, + {"MCGetWindowRgn", (PyCFunction)Qt_MCGetWindowRgn, 1, + "(MovieController mc, WindowPtr w) -> (RgnHandle _rv)"}, + {"MCMovieChanged", (PyCFunction)Qt_MCMovieChanged, 1, + "(MovieController mc, Movie m) -> (ComponentResult _rv)"}, + {"MCSetDuration", (PyCFunction)Qt_MCSetDuration, 1, + "(MovieController mc, TimeValue duration) -> (ComponentResult _rv)"}, + {"MCGetCurrentTime", (PyCFunction)Qt_MCGetCurrentTime, 1, + "(MovieController mc) -> (TimeValue _rv, TimeScale scale)"}, + {"MCNewAttachedController", (PyCFunction)Qt_MCNewAttachedController, 1, + "(MovieController mc, Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)"}, + {"MCDraw", (PyCFunction)Qt_MCDraw, 1, + "(MovieController mc, WindowPtr w) -> (ComponentResult _rv)"}, + {"MCActivate", (PyCFunction)Qt_MCActivate, 1, + "(MovieController mc, WindowPtr w, Boolean activate) -> (ComponentResult _rv)"}, + {"MCIdle", (PyCFunction)Qt_MCIdle, 1, + "(MovieController mc) -> (ComponentResult _rv)"}, + {"MCKey", (PyCFunction)Qt_MCKey, 1, + "(MovieController mc, SInt8 key, long modifiers) -> (ComponentResult _rv)"}, + {"MCClick", (PyCFunction)Qt_MCClick, 1, + "(MovieController mc, WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)"}, + {"MCEnableEditing", (PyCFunction)Qt_MCEnableEditing, 1, + "(MovieController mc, Boolean enabled) -> (ComponentResult _rv)"}, + {"MCIsEditingEnabled", (PyCFunction)Qt_MCIsEditingEnabled, 1, + "(MovieController mc) -> (long _rv)"}, + {"MCCopy", (PyCFunction)Qt_MCCopy, 1, + "(MovieController mc) -> (Movie _rv)"}, + {"MCCut", (PyCFunction)Qt_MCCut, 1, + "(MovieController mc) -> (Movie _rv)"}, + {"MCPaste", (PyCFunction)Qt_MCPaste, 1, + "(MovieController mc, Movie srcMovie) -> (ComponentResult _rv)"}, + {"MCClear", (PyCFunction)Qt_MCClear, 1, + "(MovieController mc) -> (ComponentResult _rv)"}, + {"MCUndo", (PyCFunction)Qt_MCUndo, 1, + "(MovieController mc) -> (ComponentResult _rv)"}, + {"MCPositionController", (PyCFunction)Qt_MCPositionController, 1, + "(MovieController mc, Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)"}, + {"MCGetControllerInfo", (PyCFunction)Qt_MCGetControllerInfo, 1, + "(MovieController mc) -> (ComponentResult _rv, long someFlags)"}, + {"MCSetClip", (PyCFunction)Qt_MCSetClip, 1, + "(MovieController mc, RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)"}, + {"MCGetClip", (PyCFunction)Qt_MCGetClip, 1, + "(MovieController mc) -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)"}, + {"MCDrawBadge", (PyCFunction)Qt_MCDrawBadge, 1, + "(MovieController mc, RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)"}, + {"MCSetUpEditMenu", (PyCFunction)Qt_MCSetUpEditMenu, 1, + "(MovieController mc, long modifiers, MenuHandle mh) -> (ComponentResult _rv)"}, + {"MCGetMenuString", (PyCFunction)Qt_MCGetMenuString, 1, + "(MovieController mc, long modifiers, short item, Str255 aString) -> (ComponentResult _rv)"}, + {"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1, + "() -> (TimeBase _rv)"}, + {NULL, NULL, 0} +}; + + + + +void initQt() +{ + PyObject *m; + PyObject *d; + + + + + m = Py_InitModule("Qt", Qt_methods); + d = PyModule_GetDict(m); + Qt_Error = PyMac_GetOSErrException(); + if (Qt_Error == NULL || + PyDict_SetItemString(d, "Error", Qt_Error) != 0) + Py_FatalError("can't initialize Qt.Error"); +} + +/* ========================= End module Qt ========================== */ + diff --git a/Mac/Modules/qt/qtgen.py b/Mac/Modules/qt/qtgen.py index 5b9e5a7b80d..2fe17428c85 100644 --- a/Mac/Modules/qt/qtgen.py +++ b/Mac/Modules/qt/qtgen.py @@ -24,14 +24,14 @@ (Movie, 'theMovie', InMode), (long, 'maxMilliSecToUse', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(OSErr, 'PrerollMovie', (Movie, 'theMovie', InMode), (TimeValue, 'time', InMode), (Fixed, 'Rate', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(OSErr, 'LoadMovieIntoRam', (Movie, 'theMovie', InMode), @@ -39,119 +39,200 @@ (TimeValue, 'duration', InMode), (long, 'flags', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(OSErr, 'LoadTrackIntoRam', + (Track, 'theTrack', InMode), + (TimeValue, 'time', InMode), + (TimeValue, 'duration', InMode), + (long, 'flags', InMode), +) +Track_methods.append(f) + +f = Method(OSErr, 'LoadMediaIntoRam', + (Media, 'theMedia', InMode), + (TimeValue, 'time', InMode), + (TimeValue, 'duration', InMode), + (long, 'flags', InMode), +) +Media_methods.append(f) f = Method(void, 'SetMovieActive', (Movie, 'theMovie', InMode), (Boolean, 'active', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(Boolean, 'GetMovieActive', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'StartMovie', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'StopMovie', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'GoToBeginningOfMovie', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'GoToEndOfMovie', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(Boolean, 'IsMovieDone', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(Boolean, 'GetMoviePreviewMode', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetMoviePreviewMode', (Movie, 'theMovie', InMode), (Boolean, 'usePreview', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'ShowMoviePoster', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(TimeBase, 'GetMovieTimeBase', + (Movie, 'theMovie', InMode), +) +Movie_methods.append(f) + +f = Method(Track, 'GetNextTrackForCompositing', + (Movie, 'theMovie', InMode), + (Track, 'theTrack', InMode), +) +Movie_methods.append(f) + +f = Method(Track, 'GetPrevTrackForCompositing', + (Movie, 'theMovie', InMode), + (Track, 'theTrack', InMode), +) +Movie_methods.append(f) f = Method(PicHandle, 'GetMoviePict', (Movie, 'theMovie', InMode), (TimeValue, 'time', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(PicHandle, 'GetTrackPict', + (Track, 'theTrack', InMode), + (TimeValue, 'time', InMode), +) +Track_methods.append(f) f = Method(PicHandle, 'GetMoviePosterPict', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(OSErr, 'UpdateMovie', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'GetMovieBox', (Movie, 'theMovie', InMode), (Rect, 'boxRect', OutMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetMovieBox', (Movie, 'theMovie', InMode), (Rect_ptr, 'boxRect', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(RgnHandle, 'GetMovieDisplayClipRgn', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetMovieDisplayClipRgn', (Movie, 'theMovie', InMode), (RgnHandle, 'theClip', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(RgnHandle, 'GetMovieClipRgn', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetMovieClipRgn', (Movie, 'theMovie', InMode), (RgnHandle, 'theClip', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(RgnHandle, 'GetTrackClipRgn', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(void, 'SetTrackClipRgn', + (Track, 'theTrack', InMode), + (RgnHandle, 'theClip', InMode), +) +Track_methods.append(f) f = Method(RgnHandle, 'GetMovieDisplayBoundsRgn', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(RgnHandle, 'GetTrackDisplayBoundsRgn', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) f = Method(RgnHandle, 'GetMovieBoundsRgn', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(RgnHandle, 'GetTrackMovieBoundsRgn', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(RgnHandle, 'GetTrackBoundsRgn', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(PixMapHandle, 'GetTrackMatte', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(void, 'SetTrackMatte', + (Track, 'theTrack', InMode), + (PixMapHandle, 'theMatte', InMode), +) +Track_methods.append(f) + +f = Function(void, 'DisposeMatte', + (PixMapHandle, 'theMatte', InMode), +) +functions.append(f) f = Function(Movie, 'NewMovie', (long, 'flags', InMode), @@ -162,7 +243,7 @@ (Movie, 'theMovie', InMode), (Handle, 'publicMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(OSErr, 'PutMovieIntoDataFork', (Movie, 'theMovie', InMode), @@ -170,142 +251,542 @@ (long, 'offset', InMode), (long, 'maxSize', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(TimeScale, 'GetMovieTimeScale', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetMovieTimeScale', (Movie, 'theMovie', InMode), (TimeScale, 'timeScale', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(TimeValue, 'GetMovieDuration', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(Fixed, 'GetMovieRate', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetMovieRate', (Movie, 'theMovie', InMode), (Fixed, 'rate', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(Fixed, 'GetMoviePreferredRate', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetMoviePreferredRate', (Movie, 'theMovie', InMode), (Fixed, 'rate', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(short, 'GetMoviePreferredVolume', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetMoviePreferredVolume', (Movie, 'theMovie', InMode), (short, 'volume', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(short, 'GetMovieVolume', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetMovieVolume', (Movie, 'theMovie', InMode), (short, 'volume', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'GetMoviePreviewTime', (Movie, 'theMovie', InMode), (TimeValue, 'previewTime', OutMode), (TimeValue, 'previewDuration', OutMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetMoviePreviewTime', (Movie, 'theMovie', InMode), (TimeValue, 'previewTime', InMode), (TimeValue, 'previewDuration', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(TimeValue, 'GetMoviePosterTime', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetMoviePosterTime', (Movie, 'theMovie', InMode), (TimeValue, 'posterTime', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'GetMovieSelection', (Movie, 'theMovie', InMode), (TimeValue, 'selectionTime', OutMode), (TimeValue, 'selectionDuration', OutMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetMovieSelection', (Movie, 'theMovie', InMode), (TimeValue, 'selectionTime', InMode), (TimeValue, 'selectionDuration', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetMovieActiveSegment', (Movie, 'theMovie', InMode), (TimeValue, 'startTime', InMode), (TimeValue, 'duration', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'GetMovieActiveSegment', (Movie, 'theMovie', InMode), (TimeValue, 'startTime', OutMode), (TimeValue, 'duration', OutMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetMovieTimeValue', (Movie, 'theMovie', InMode), (TimeValue, 'newtime', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(UserData, 'GetMovieUserData', + (Movie, 'theMovie', InMode), +) +Movie_methods.append(f) f = Method(long, 'GetMovieTrackCount', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(Track, 'GetMovieTrack', + (Movie, 'theMovie', InMode), + (long, 'trackID', InMode), +) +Movie_methods.append(f) + +f = Method(Track, 'GetMovieIndTrack', + (Movie, 'theMovie', InMode), + (long, 'index', InMode), +) +Movie_methods.append(f) + +f = Method(Track, 'GetMovieIndTrackType', + (Movie, 'theMovie', InMode), + (long, 'index', InMode), + (OSType, 'trackType', InMode), + (long, 'flags', InMode), +) +Movie_methods.append(f) + +f = Method(long, 'GetTrackID', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(Movie, 'GetTrackMovie', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(Track, 'NewMovieTrack', + (Movie, 'theMovie', InMode), + (Fixed, 'width', InMode), + (Fixed, 'height', InMode), + (short, 'trackVolume', InMode), +) +Movie_methods.append(f) + +f = Method(Boolean, 'GetTrackEnabled', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(void, 'SetTrackEnabled', + (Track, 'theTrack', InMode), + (Boolean, 'isEnabled', InMode), +) +Track_methods.append(f) + +f = Method(long, 'GetTrackUsage', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(void, 'SetTrackUsage', + (Track, 'theTrack', InMode), + (long, 'usage', InMode), +) +Track_methods.append(f) + +f = Method(TimeValue, 'GetTrackDuration', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(TimeValue, 'GetTrackOffset', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(void, 'SetTrackOffset', + (Track, 'theTrack', InMode), + (TimeValue, 'movieOffsetTime', InMode), +) +Track_methods.append(f) + +f = Method(short, 'GetTrackLayer', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(void, 'SetTrackLayer', + (Track, 'theTrack', InMode), + (short, 'layer', InMode), +) +Track_methods.append(f) + +f = Method(Track, 'GetTrackAlternate', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(void, 'SetTrackAlternate', + (Track, 'theTrack', InMode), + (Track, 'alternateT', InMode), +) +Track_methods.append(f) f = Method(void, 'SetAutoTrackAlternatesEnabled', (Movie, 'theMovie', InMode), (Boolean, 'enable', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SelectMovieAlternates', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(short, 'GetTrackVolume', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(void, 'SetTrackVolume', + (Track, 'theTrack', InMode), + (short, 'volume', InMode), +) +Track_methods.append(f) + +f = Method(void, 'GetTrackDimensions', + (Track, 'theTrack', InMode), + (Fixed, 'width', OutMode), + (Fixed, 'height', OutMode), +) +Track_methods.append(f) + +f = Method(void, 'SetTrackDimensions', + (Track, 'theTrack', InMode), + (Fixed, 'width', InMode), + (Fixed, 'height', InMode), +) +Track_methods.append(f) + +f = Method(UserData, 'GetTrackUserData', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(Media, 'NewTrackMedia', + (Track, 'theTrack', InMode), + (OSType, 'mediaType', InMode), + (TimeScale, 'timeScale', InMode), + (Handle, 'dataRef', InMode), + (OSType, 'dataRefType', InMode), +) +Track_methods.append(f) + +f = Method(Media, 'GetTrackMedia', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(Track, 'GetMediaTrack', + (Media, 'theMedia', InMode), +) +Media_methods.append(f) + +f = Method(TimeScale, 'GetMediaTimeScale', + (Media, 'theMedia', InMode), +) +Media_methods.append(f) + +f = Method(void, 'SetMediaTimeScale', + (Media, 'theMedia', InMode), + (TimeScale, 'timeScale', InMode), +) +Media_methods.append(f) + +f = Method(TimeValue, 'GetMediaDuration', + (Media, 'theMedia', InMode), +) +Media_methods.append(f) + +f = Method(short, 'GetMediaLanguage', + (Media, 'theMedia', InMode), +) +Media_methods.append(f) + +f = Method(void, 'SetMediaLanguage', + (Media, 'theMedia', InMode), + (short, 'language', InMode), +) +Media_methods.append(f) + +f = Method(short, 'GetMediaQuality', + (Media, 'theMedia', InMode), +) +Media_methods.append(f) + +f = Method(void, 'SetMediaQuality', + (Media, 'theMedia', InMode), + (short, 'quality', InMode), +) +Media_methods.append(f) + +f = Method(void, 'GetMediaHandlerDescription', + (Media, 'theMedia', InMode), + (OSType, 'mediaType', OutMode), + (Str255, 'creatorName', InMode), + (OSType, 'creatorManufacturer', OutMode), +) +Media_methods.append(f) + +f = Method(UserData, 'GetMediaUserData', + (Media, 'theMedia', InMode), +) +Media_methods.append(f) + +f = Method(MediaHandler, 'GetMediaHandler', + (Media, 'theMedia', InMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'SetMediaHandler', + (Media, 'theMedia', InMode), + (MediaHandlerComponent, 'mH', InMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'BeginMediaEdits', + (Media, 'theMedia', InMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'EndMediaEdits', + (Media, 'theMedia', InMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'SetMediaDefaultDataRefIndex', + (Media, 'theMedia', InMode), + (short, 'index', InMode), +) +Media_methods.append(f) + +f = Method(void, 'GetMediaDataHandlerDescription', + (Media, 'theMedia', InMode), + (short, 'index', InMode), + (OSType, 'dhType', OutMode), + (Str255, 'creatorName', InMode), + (OSType, 'creatorManufacturer', OutMode), +) +Media_methods.append(f) + +f = Method(DataHandler, 'GetMediaDataHandler', + (Media, 'theMedia', InMode), + (short, 'index', InMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'SetMediaDataHandler', + (Media, 'theMedia', InMode), + (short, 'index', InMode), + (DataHandlerComponent, 'dataHandler', InMode), +) +Media_methods.append(f) + +f = Function(Component, 'GetDataHandler', + (Handle, 'dataRef', InMode), + (OSType, 'dataHandlerSubType', InMode), + (long, 'flags', InMode), +) +functions.append(f) + +f = Method(long, 'GetMediaSampleDescriptionCount', + (Media, 'theMedia', InMode), +) +Media_methods.append(f) + +f = Method(void, 'GetMediaSampleDescription', + (Media, 'theMedia', InMode), + (long, 'index', InMode), + (SampleDescriptionHandle, 'descH', InMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'SetMediaSampleDescription', + (Media, 'theMedia', InMode), + (long, 'index', InMode), + (SampleDescriptionHandle, 'descH', InMode), +) +Media_methods.append(f) + +f = Method(long, 'GetMediaSampleCount', + (Media, 'theMedia', InMode), +) +Media_methods.append(f) + +f = Method(void, 'SampleNumToMediaTime', + (Media, 'theMedia', InMode), + (long, 'logicalSampleNum', InMode), + (TimeValue, 'sampleTime', OutMode), + (TimeValue, 'sampleDuration', OutMode), +) +Media_methods.append(f) + +f = Method(void, 'MediaTimeToSampleNum', + (Media, 'theMedia', InMode), + (TimeValue, 'time', InMode), + (long, 'sampleNum', OutMode), + (TimeValue, 'sampleTime', OutMode), + (TimeValue, 'sampleDuration', OutMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'AddMediaSample', + (Media, 'theMedia', InMode), + (Handle, 'dataIn', InMode), + (long, 'inOffset', InMode), + (unsigned_long, 'size', InMode), + (TimeValue, 'durationPerSample', InMode), + (SampleDescriptionHandle, 'sampleDescriptionH', InMode), + (long, 'numberOfSamples', InMode), + (short, 'sampleFlags', InMode), + (TimeValue, 'sampleTime', OutMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'AddMediaSampleReference', + (Media, 'theMedia', InMode), + (long, 'dataOffset', InMode), + (unsigned_long, 'size', InMode), + (TimeValue, 'durationPerSample', InMode), + (SampleDescriptionHandle, 'sampleDescriptionH', InMode), + (long, 'numberOfSamples', InMode), + (short, 'sampleFlags', InMode), + (TimeValue, 'sampleTime', OutMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'GetMediaSample', + (Media, 'theMedia', InMode), + (Handle, 'dataOut', InMode), + (long, 'maxSizeToGrow', InMode), + (long, 'size', OutMode), + (TimeValue, 'time', InMode), + (TimeValue, 'sampleTime', OutMode), + (TimeValue, 'durationPerSample', OutMode), + (SampleDescriptionHandle, 'sampleDescriptionH', InMode), + (long, 'sampleDescriptionIndex', OutMode), + (long, 'maxNumberOfSamples', InMode), + (long, 'numberOfSamples', OutMode), + (short, 'sampleFlags', OutMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'GetMediaSampleReference', + (Media, 'theMedia', InMode), + (long, 'dataOffset', OutMode), + (long, 'size', OutMode), + (TimeValue, 'time', InMode), + (TimeValue, 'sampleTime', OutMode), + (TimeValue, 'durationPerSample', OutMode), + (SampleDescriptionHandle, 'sampleDescriptionH', InMode), + (long, 'sampleDescriptionIndex', OutMode), + (long, 'maxNumberOfSamples', InMode), + (long, 'numberOfSamples', OutMode), + (short, 'sampleFlags', OutMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'SetMediaPreferredChunkSize', + (Media, 'theMedia', InMode), + (long, 'maxChunkSize', InMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'GetMediaPreferredChunkSize', + (Media, 'theMedia', InMode), + (long, 'maxChunkSize', OutMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'SetMediaShadowSync', + (Media, 'theMedia', InMode), + (long, 'frameDiffSampleNum', InMode), + (long, 'syncSampleNum', InMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'GetMediaShadowSync', + (Media, 'theMedia', InMode), + (long, 'frameDiffSampleNum', InMode), + (long, 'syncSampleNum', OutMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'InsertMediaIntoTrack', + (Track, 'theTrack', InMode), + (TimeValue, 'trackStart', InMode), + (TimeValue, 'mediaTime', InMode), + (TimeValue, 'mediaDuration', InMode), + (Fixed, 'mediaRate', InMode), +) +Track_methods.append(f) + +f = Method(OSErr, 'InsertTrackSegment', + (Track, 'srcTrack', InMode), + (Track, 'dstTrack', InMode), + (TimeValue, 'srcIn', InMode), + (TimeValue, 'srcDuration', InMode), + (TimeValue, 'dstIn', InMode), +) +Track_methods.append(f) f = Method(OSErr, 'InsertMovieSegment', (Movie, 'srcMovie', InMode), @@ -314,21 +795,43 @@ (TimeValue, 'srcDuration', InMode), (TimeValue, 'dstIn', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(OSErr, 'InsertEmptyTrackSegment', + (Track, 'dstTrack', InMode), + (TimeValue, 'dstIn', InMode), + (TimeValue, 'dstDuration', InMode), +) +Track_methods.append(f) f = Method(OSErr, 'InsertEmptyMovieSegment', (Movie, 'dstMovie', InMode), (TimeValue, 'dstIn', InMode), (TimeValue, 'dstDuration', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(OSErr, 'DeleteTrackSegment', + (Track, 'theTrack', InMode), + (TimeValue, 'startTime', InMode), + (TimeValue, 'duration', InMode), +) +Track_methods.append(f) f = Method(OSErr, 'DeleteMovieSegment', (Movie, 'theMovie', InMode), (TimeValue, 'startTime', InMode), (TimeValue, 'duration', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(OSErr, 'ScaleTrackSegment', + (Track, 'theTrack', InMode), + (TimeValue, 'startTime', InMode), + (TimeValue, 'oldDuration', InMode), + (TimeValue, 'newDuration', InMode), +) +Track_methods.append(f) f = Method(OSErr, 'ScaleMovieSegment', (Movie, 'theMovie', InMode), @@ -336,34 +839,34 @@ (TimeValue, 'oldDuration', InMode), (TimeValue, 'newDuration', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(Movie, 'CutMovieSelection', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(Movie, 'CopyMovieSelection', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'PasteMovieSelection', (Movie, 'theMovie', InMode), (Movie, 'src', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'AddMovieSelection', (Movie, 'theMovie', InMode), (Movie, 'src', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'ClearMovieSelection', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Function(OSErr, 'PasteHandleIntoMovie', (Handle, 'h', InMode), @@ -374,30 +877,246 @@ ) functions.append(f) +f = Method(OSErr, 'PutMovieIntoTypedHandle', + (Movie, 'theMovie', InMode), + (Track, 'targetTrack', InMode), + (OSType, 'handleType', InMode), + (Handle, 'publicMovie', InMode), + (TimeValue, 'start', InMode), + (TimeValue, 'dur', InMode), + (long, 'flags', InMode), + (ComponentInstance, 'userComp', InMode), +) +Movie_methods.append(f) + +f = Method(Component, 'IsScrapMovie', + (Track, 'targetTrack', InMode), +) +Track_methods.append(f) + +f = Method(OSErr, 'CopyTrackSettings', + (Track, 'srcTrack', InMode), + (Track, 'dstTrack', InMode), +) +Track_methods.append(f) + f = Method(OSErr, 'CopyMovieSettings', (Movie, 'srcMovie', InMode), (Movie, 'dstMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(OSErr, 'AddEmptyTrackToMovie', + (Track, 'srcTrack', InMode), + (Movie, 'dstMovie', InMode), + (Handle, 'dataRef', InMode), + (OSType, 'dataRefType', InMode), + (Track, 'dstTrack', OutMode), +) +Track_methods.append(f) + +f = Method(OSErr, 'AddTrackReference', + (Track, 'theTrack', InMode), + (Track, 'refTrack', InMode), + (OSType, 'refType', InMode), + (long, 'addedIndex', OutMode), +) +Track_methods.append(f) + +f = Method(OSErr, 'DeleteTrackReference', + (Track, 'theTrack', InMode), + (OSType, 'refType', InMode), + (long, 'index', InMode), +) +Track_methods.append(f) + +f = Method(OSErr, 'SetTrackReference', + (Track, 'theTrack', InMode), + (Track, 'refTrack', InMode), + (OSType, 'refType', InMode), + (long, 'index', InMode), +) +Track_methods.append(f) + +f = Method(Track, 'GetTrackReference', + (Track, 'theTrack', InMode), + (OSType, 'refType', InMode), + (long, 'index', InMode), +) +Track_methods.append(f) + +f = Method(OSType, 'GetNextTrackReferenceType', + (Track, 'theTrack', InMode), + (OSType, 'refType', InMode), +) +Track_methods.append(f) + +f = Method(long, 'GetTrackReferenceCount', + (Track, 'theTrack', InMode), + (OSType, 'refType', InMode), +) +Track_methods.append(f) + +f = Method(OSErr, 'ConvertMovieToFile', + (Movie, 'theMovie', InMode), + (Track, 'onlyTrack', InMode), + (FSSpec_ptr, 'outputFile', InMode), + (OSType, 'fileType', InMode), + (OSType, 'creator', InMode), + (ScriptCode, 'scriptTag', InMode), + (short, 'resID', OutMode), + (long, 'flags', InMode), + (ComponentInstance, 'userComp', InMode), +) +Movie_methods.append(f) + +f = Function(TimeValue, 'TrackTimeToMediaTime', + (TimeValue, 'value', InMode), + (Track, 'theTrack', InMode), +) +functions.append(f) + +f = Method(Fixed, 'GetTrackEditRate', + (Track, 'theTrack', InMode), + (TimeValue, 'atTime', InMode), +) +Track_methods.append(f) f = Method(long, 'GetMovieDataSize', (Movie, 'theMovie', InMode), (TimeValue, 'startTime', InMode), (TimeValue, 'duration', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(long, 'GetTrackDataSize', + (Track, 'theTrack', InMode), + (TimeValue, 'startTime', InMode), + (TimeValue, 'duration', InMode), +) +Track_methods.append(f) + +f = Method(long, 'GetMediaDataSize', + (Media, 'theMedia', InMode), + (TimeValue, 'startTime', InMode), + (TimeValue, 'duration', InMode), +) +Media_methods.append(f) f = Method(Boolean, 'PtInMovie', (Movie, 'theMovie', InMode), (Point, 'pt', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(Boolean, 'PtInTrack', + (Track, 'theTrack', InMode), + (Point, 'pt', InMode), +) +Track_methods.append(f) f = Method(void, 'SetMovieLanguage', (Movie, 'theMovie', InMode), (long, 'language', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(OSErr, 'GetUserData', + (UserData, 'theUserData', InMode), + (Handle, 'data', InMode), + (OSType, 'udType', InMode), + (long, 'index', InMode), +) +UserData_methods.append(f) + +f = Method(OSErr, 'AddUserData', + (UserData, 'theUserData', InMode), + (Handle, 'data', InMode), + (OSType, 'udType', InMode), +) +UserData_methods.append(f) + +f = Method(OSErr, 'RemoveUserData', + (UserData, 'theUserData', InMode), + (OSType, 'udType', InMode), + (long, 'index', InMode), +) +UserData_methods.append(f) + +f = Method(short, 'CountUserDataType', + (UserData, 'theUserData', InMode), + (OSType, 'udType', InMode), +) +UserData_methods.append(f) + +f = Method(long, 'GetNextUserDataType', + (UserData, 'theUserData', InMode), + (OSType, 'udType', InMode), +) +UserData_methods.append(f) + +f = Method(OSErr, 'AddUserDataText', + (UserData, 'theUserData', InMode), + (Handle, 'data', InMode), + (OSType, 'udType', InMode), + (long, 'index', InMode), + (short, 'itlRegionTag', InMode), +) +UserData_methods.append(f) + +f = Method(OSErr, 'GetUserDataText', + (UserData, 'theUserData', InMode), + (Handle, 'data', InMode), + (OSType, 'udType', InMode), + (long, 'index', InMode), + (short, 'itlRegionTag', InMode), +) +UserData_methods.append(f) + +f = Method(OSErr, 'RemoveUserDataText', + (UserData, 'theUserData', InMode), + (OSType, 'udType', InMode), + (long, 'index', InMode), + (short, 'itlRegionTag', InMode), +) +UserData_methods.append(f) + +f = Function(OSErr, 'NewUserData', + (UserData, 'theUserData', OutMode), +) +functions.append(f) + +f = Function(OSErr, 'NewUserDataFromHandle', + (Handle, 'h', InMode), + (UserData, 'theUserData', OutMode), +) +functions.append(f) + +f = Method(OSErr, 'PutUserDataIntoHandle', + (UserData, 'theUserData', InMode), + (Handle, 'h', InMode), +) +UserData_methods.append(f) + +f = Method(void, 'GetMediaNextInterestingTime', + (Media, 'theMedia', InMode), + (short, 'interestingTimeFlags', InMode), + (TimeValue, 'time', InMode), + (Fixed, 'rate', InMode), + (TimeValue, 'interestingTime', OutMode), + (TimeValue, 'interestingDuration', OutMode), +) +Media_methods.append(f) + +f = Method(void, 'GetTrackNextInterestingTime', + (Track, 'theTrack', InMode), + (short, 'interestingTimeFlags', InMode), + (TimeValue, 'time', InMode), + (Fixed, 'rate', InMode), + (TimeValue, 'interestingTime', OutMode), + (TimeValue, 'interestingDuration', OutMode), +) +Track_methods.append(f) f = Method(void, 'GetMovieNextInterestingTime', (Movie, 'theMovie', InMode), @@ -409,7 +1128,7 @@ (TimeValue, 'interestingTime', OutMode), (TimeValue, 'interestingDuration', OutMode), ) -methods.append(f) +Movie_methods.append(f) f = Function(OSErr, 'CreateMovieFile', (FSSpec_ptr, 'fileSpec', InMode), @@ -465,24 +1184,13 @@ ) functions.append(f) -f = Function(OSErr, 'NewMovieFromUserProc', - (Movie, 'm', OutMode), - (short, 'flags', InMode), - (Boolean, 'dataRefWasChanged', OutMode), - (GetMovieUPP, 'getProc', InMode), - (void, 'refCon', OutMode), - (Handle, 'defaultDataRef', InMode), - (OSType, 'dataRefType', InMode), -) -functions.append(f) - f = Method(OSErr, 'AddMovieResource', (Movie, 'theMovie', InMode), (short, 'resRefNum', InMode), (short, 'resId', OutMode), (ConstStr255Param, 'resName', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(OSErr, 'UpdateMovieResource', (Movie, 'theMovie', InMode), @@ -490,7 +1198,7 @@ (short, 'resId', InMode), (ConstStr255Param, 'resName', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Function(OSErr, 'RemoveMovieResource', (short, 'resRefNum', InMode), @@ -501,38 +1209,38 @@ f = Method(Boolean, 'HasMovieChanged', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'ClearMovieChanged', (Movie, 'theMovie', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(OSErr, 'SetMovieDefaultDataRef', (Movie, 'theMovie', InMode), (Handle, 'dataRef', InMode), (OSType, 'dataRefType', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(OSErr, 'GetMovieDefaultDataRef', (Movie, 'theMovie', InMode), (Handle, 'dataRef', OutMode), (OSType, 'dataRefType', OutMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(OSErr, 'SetMovieColorTable', (Movie, 'theMovie', InMode), (CTabHandle, 'ctab', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(OSErr, 'GetMovieColorTable', (Movie, 'theMovie', InMode), (CTabHandle, 'ctab', OutMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'FlattenMovie', (Movie, 'theMovie', InMode), @@ -544,7 +1252,7 @@ (short, 'resId', OutMode), (ConstStr255Param, 'resName', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(Movie, 'FlattenMovieData', (Movie, 'theMovie', InMode), @@ -554,7 +1262,7 @@ (ScriptCode, 'scriptTag', InMode), (long, 'createMovieFileFlags', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Function(HandlerError, 'GetVideoMediaGraphicsMode', (MediaHandler, 'mh', InMode), @@ -582,53 +1290,6 @@ ) functions.append(f) -f = Function(ComponentResult, 'AddTextSample', - (MediaHandler, 'mh', InMode), - (Ptr, 'text', InMode), - (unsigned_long, 'size', InMode), - (short, 'fontNumber', InMode), - (short, 'fontSize', InMode), - (short, 'textFace', InMode), - (RGBColor, 'textColor', OutMode), - (RGBColor, 'backColor', OutMode), - (short, 'textJustification', InMode), - (Rect, 'textBox', OutMode), - (long, 'displayFlags', InMode), - (TimeValue, 'scrollDelay', InMode), - (short, 'hiliteStart', InMode), - (short, 'hiliteEnd', InMode), - (RGBColor, 'rgbHiliteColor', OutMode), - (TimeValue, 'duration', InMode), - (TimeValue, 'sampleTime', OutMode), -) -functions.append(f) - -f = Function(ComponentResult, 'AddTESample', - (MediaHandler, 'mh', InMode), - (TEHandle, 'hTE', InMode), - (RGBColor, 'backColor', OutMode), - (short, 'textJustification', InMode), - (Rect, 'textBox', OutMode), - (long, 'displayFlags', InMode), - (TimeValue, 'scrollDelay', InMode), - (short, 'hiliteStart', InMode), - (short, 'hiliteEnd', InMode), - (RGBColor, 'rgbHiliteColor', OutMode), - (TimeValue, 'duration', InMode), - (TimeValue, 'sampleTime', OutMode), -) -functions.append(f) - -f = Function(ComponentResult, 'AddHiliteSample', - (MediaHandler, 'mh', InMode), - (short, 'hiliteStart', InMode), - (short, 'hiliteEnd', InMode), - (RGBColor, 'rgbHiliteColor', OutMode), - (TimeValue, 'duration', InMode), - (TimeValue, 'sampleTime', OutMode), -) -functions.append(f) - f = Function(ComponentResult, 'FindNextText', (MediaHandler, 'mh', InMode), (Ptr, 'text', InMode), @@ -641,77 +1302,146 @@ ) functions.append(f) -f = Function(ComponentResult, 'HiliteTextSample', - (MediaHandler, 'mh', InMode), - (TimeValue, 'sampleTime', InMode), - (short, 'hiliteStart', InMode), - (short, 'hiliteEnd', InMode), - (RGBColor, 'rgbHiliteColor', OutMode), +f = Method(OSErr, 'MovieSearchText', + (Movie, 'theMovie', InMode), + (Ptr, 'text', InMode), + (long, 'size', InMode), + (long, 'searchFlags', InMode), + (Track, 'searchTrack', OutMode), + (TimeValue, 'searchTime', OutMode), + (long, 'searchOffset', OutMode), ) -functions.append(f) - -f = Function(ComponentResult, 'SetTextSampleData', - (MediaHandler, 'mh', InMode), - (void, 'data', OutMode), - (OSType, 'dataType', InMode), -) -functions.append(f) +Movie_methods.append(f) f = Method(void, 'GetPosterBox', (Movie, 'theMovie', InMode), (Rect, 'boxRect', OutMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(void, 'SetPosterBox', (Movie, 'theMovie', InMode), (Rect_ptr, 'boxRect', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Method(RgnHandle, 'GetMovieSegmentDisplayBoundsRgn', (Movie, 'theMovie', InMode), (TimeValue, 'time', InMode), (TimeValue, 'duration', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(RgnHandle, 'GetTrackSegmentDisplayBoundsRgn', + (Track, 'theTrack', InMode), + (TimeValue, 'time', InMode), + (TimeValue, 'duration', InMode), +) +Track_methods.append(f) + +f = Method(ComponentResult, 'GetTrackStatus', + (Track, 'theTrack', InMode), +) +Track_methods.append(f) + +f = Method(ComponentResult, 'GetMovieStatus', + (Movie, 'theMovie', InMode), + (Track, 'firstProblemTrack', OutMode), +) +Movie_methods.append(f) f = Method(ComponentInstance, 'NewMovieController', (Movie, 'theMovie', InMode), (Rect_ptr, 'movieRect', InMode), (long, 'someFlags', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Function(void, 'DisposeMovieController', (ComponentInstance, 'mc', InMode), ) functions.append(f) -f = Method(void, 'ShowMovieInformation', - (Movie, 'theMovie', InMode), - (ModalFilterUPP, 'filterProc', InMode), - (long, 'refCon', InMode), -) -methods.append(f) - f = Method(OSErr, 'PutMovieOnScrap', (Movie, 'theMovie', InMode), (long, 'movieScrapFlags', InMode), ) -methods.append(f) +Movie_methods.append(f) f = Function(Movie, 'NewMovieFromScrap', (long, 'newMovieFlags', InMode), ) functions.append(f) +f = Method(OSErr, 'GetMediaDataRef', + (Media, 'theMedia', InMode), + (short, 'index', InMode), + (Handle, 'dataRef', OutMode), + (OSType, 'dataRefType', OutMode), + (long, 'dataRefAttributes', OutMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'SetMediaDataRef', + (Media, 'theMedia', InMode), + (short, 'index', InMode), + (Handle, 'dataRef', InMode), + (OSType, 'dataRefType', InMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'SetMediaDataRefAttributes', + (Media, 'theMedia', InMode), + (short, 'index', InMode), + (long, 'dataRefAttributes', InMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'AddMediaDataRef', + (Media, 'theMedia', InMode), + (short, 'index', OutMode), + (Handle, 'dataRef', InMode), + (OSType, 'dataRefType', InMode), +) +Media_methods.append(f) + +f = Method(OSErr, 'GetMediaDataRefCount', + (Media, 'theMedia', InMode), + (short, 'count', OutMode), +) +Media_methods.append(f) + f = Method(void, 'SetMoviePlayHints', (Movie, 'theMovie', InMode), (long, 'flags', InMode), (long, 'flagsMask', InMode), ) -methods.append(f) +Movie_methods.append(f) + +f = Method(void, 'SetMediaPlayHints', + (Media, 'theMedia', InMode), + (long, 'flags', InMode), + (long, 'flagsMask', InMode), +) +Media_methods.append(f) + +f = Method(void, 'SetTrackLoadSettings', + (Track, 'theTrack', InMode), + (TimeValue, 'preloadTime', InMode), + (TimeValue, 'preloadDuration', InMode), + (long, 'preloadFlags', InMode), + (long, 'defaultHints', InMode), +) +Track_methods.append(f) + +f = Method(void, 'GetTrackLoadSettings', + (Track, 'theTrack', InMode), + (TimeValue, 'preloadTime', OutMode), + (TimeValue, 'preloadDuration', OutMode), + (long, 'preloadFlags', OutMode), + (long, 'defaultHints', OutMode), +) +Track_methods.append(f) f = Function(ComponentResult, 'MCSetMovie', (MovieController, 'mc', InMode), @@ -738,13 +1468,6 @@ ) functions.append(f) -f = Function(ComponentResult, 'MCDoAction', - (MovieController, 'mc', InMode), - (short, 'action', InMode), - (void, 'params', OutMode), -) -functions.append(f) - f = Function(ComponentResult, 'MCSetControllerAttached', (MovieController, 'mc', InMode), (Boolean, 'attach', InMode), @@ -937,13 +1660,51 @@ ) functions.append(f) -f = Function(OSErr, 'QueueSyncTask', - (QTSyncTaskPtr, 'task', InMode), +f = Function(TimeBase, 'NewTimeBase', ) functions.append(f) -f = Function(OSErr, 'DequeueSyncTask', - (QTSyncTaskPtr, 'qElem', InMode), +f = Method(void, 'SetTimeBaseValue', + (TimeBase, 'tb', InMode), + (TimeValue, 't', InMode), + (TimeScale, 's', InMode), ) -functions.append(f) +TimeBase_methods.append(f) + +f = Method(Fixed, 'GetTimeBaseRate', + (TimeBase, 'tb', InMode), +) +TimeBase_methods.append(f) + +f = Method(void, 'SetTimeBaseRate', + (TimeBase, 'tb', InMode), + (Fixed, 'r', InMode), +) +TimeBase_methods.append(f) + +f = Method(long, 'GetTimeBaseFlags', + (TimeBase, 'tb', InMode), +) +TimeBase_methods.append(f) + +f = Method(void, 'SetTimeBaseFlags', + (TimeBase, 'tb', InMode), + (long, 'timeBaseFlags', InMode), +) +TimeBase_methods.append(f) + +f = Method(TimeBase, 'GetTimeBaseMasterTimeBase', + (TimeBase, 'tb', InMode), +) +TimeBase_methods.append(f) + +f = Method(ComponentInstance, 'GetTimeBaseMasterClock', + (TimeBase, 'tb', InMode), +) +TimeBase_methods.append(f) + +f = Method(Fixed, 'GetTimeBaseEffectiveRate', + (TimeBase, 'tb', InMode), +) +TimeBase_methods.append(f) diff --git a/Mac/Modules/qt/qtscan.py b/Mac/Modules/qt/qtscan.py index 4a715d6e2cf..83683feec21 100644 --- a/Mac/Modules/qt/qtscan.py +++ b/Mac/Modules/qt/qtscan.py @@ -6,7 +6,7 @@ LONG = "QuickTime" SHORT = "qt" -OBJECT = "Movie" +OBJECTS = ("Movie", "Track", "Media", "UserData", "TimeBase") def main(): input = "Movies.h" @@ -26,52 +26,75 @@ def destination(self, type, name, arglist): listname = "functions" if arglist: t, n, m = arglist[0] - if t == OBJECT and m == "InMode": + if t in OBJECTS and m == "InMode": classname = "Method" - listname = "methods" + listname = t + "_methods" return classname, listname def makeblacklistnames(self): return [ "DisposeMovie", # Done on python-object disposal + "DisposeMovieTrack", # ditto + "DisposeTrackMedia", # ditto + "DisposeUserData", # ditto + "DisposeTimeBase", # ditto "GetMovieCreationTime", # type "unsigned long" in C, inparseable "GetMovieModificationTime", # Ditto + "GetTrackCreationTime", # ditto + "GetTrackModificationTime", # Ditto + "GetMediaCreationTime", # ditto + "GetMediaModificationTime", # Ditto + # The following 4 use 'void *' in an uncontrolled way + # TBD when I've read the manual... + "GetUserDataItem", + "SetUserDataItem", + "SetTextSampleData", + "MCDoAction", + # bgen gets the argument in/out wrong.. + "AddTextSample", + "AddTESample", + "AddHiliteSample", + "HiliteTextSample", ] def makeblacklisttypes(self): return [ - "MoviesErrorUPP", - "Track", # XXXX To be done in the future - "Media", - "UserData", - "TimeBase", + # I don't think we want to do these + "QTSyncTaskPtr", + # We dont do callbacks yet, so no need for these "QTCallBack", - "Component", + # Skipped for now, due to laziness "TimeRecord", "TimeRecord_ptr", "TrackEditState", "MovieEditState", - "MoviePreviewCallOutUPP", - "CGrafPtr", - "GDHandle", - "MovieDrawingCompleteUPP", - "PixMapHandle", "MatrixRecord", "MatrixRecord_ptr", + "SampleReferencePtr", +# "SampleDescription", +# "SoundDescription", +# "TextDescription", +# "MusicDescription", + # I dont know yet how to do these. + "CGrafPtr", + "GDHandle", + # Routine pointers, not yet. + "MoviesErrorUPP", + "MoviePreviewCallOutUPP", + "MovieDrawingCompleteUPP", "QTCallBackUPP", "TextMediaUPP", "MovieProgressUPP", "MovieRgnCoverUPP", "MCActionFilterUPP", "MCActionFilterWithRefConUPP", - "SampleDescription", - "SoundDescription", - "TextDescription", - "MusicDescription", + "GetMovieUPP", + "ModalFilterUPP", ] def makerepairinstructions(self): return [ + ([('FSSpec', '*', 'OutMode')], [('FSSpec_ptr', '*', 'InMode')]), ] if __name__ == "__main__": diff --git a/Mac/Modules/qt/qtsupport.py b/Mac/Modules/qt/qtsupport.py index 5c29b75f825..ef5cac7976c 100644 --- a/Mac/Modules/qt/qtsupport.py +++ b/Mac/Modules/qt/qtsupport.py @@ -7,7 +7,7 @@ # Declarations that change for each manager MACHEADERFILE = 'Movies.h' # The Apple header file -MODNAME = 'qt' # The name of the module +MODNAME = 'Qt' # The name of the module OBJECTNAME = 'Movie' # The basic name of the objects used here # The following is *usually* unchanged but may still require tuning @@ -23,9 +23,59 @@ includestuff = includestuff + """ #include <%s>""" % MACHEADERFILE + """ + +/* Exported by Cmmodule.c: */ +extern PyObject *CmpObj_New(Component); +extern int CmpObj_Convert(PyObject *, Component *); +extern PyObject *CmpInstObj_New(ComponentInstance); +extern int CmpInstObj_Convert(PyObject *, ComponentInstance *); + +/* Exported by Qdmodule.c: */ +extern PyObject *QdRGB_New(RGBColor *); +extern int QdRGB_Convert(PyObject *, RGBColor *); + +/* Our own, used before defined: */ +staticforward PyObject *TrackObj_New(Track); +staticforward int TrackObj_Convert(PyObject *, Track *); +staticforward PyObject *MovieObj_New(Movie); +staticforward int MovieObj_Convert(PyObject *, Movie *); + + """ -Movie = OpaqueByValueType(OBJECTTYPE, OBJECTPREFIX) +# Our (opaque) objects +Movie = OpaqueByValueType('Movie', 'MovieObj') +Track = OpaqueByValueType('Track', 'TrackObj') +Media = OpaqueByValueType('Media', 'MediaObj') +UserData = OpaqueByValueType('UserData', 'UserDataObj') +TimeBase = OpaqueByValueType('TimeBase', 'TimeBaseObj') + +# Other opaque objects +Component = OpaqueByValueType('Component', 'CmpObj') +MediaHandlerComponent = OpaqueByValueType('MediaHandlerComponent', 'CmpObj') +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") +CTabHandle = OpaqueByValueType("CTabHandle", "ResObj") +PixMapHandle = OpaqueByValueType("PixMapHandle", "ResObj") +SampleDescriptionHandle = OpaqueByValueType("SampleDescriptionHandle", "ResObj") +TEHandle = OpaqueByValueType("TEHandle", "ResObj") +# Silly Apple, passing an OStype by reference... +OSType_ptr = OpaqueType("OSType", "PyMac_BuildOSType", "PyMac_GetOSType") + +RGBColor = OpaqueType("RGBColor", "QdRGB") +RGBColor_ptr = OpaqueType("RGBColor", "QdRGB") + +# Non-opaque types, mostly integer-ish TimeValue = Type("TimeValue", "l") TimeScale = Type("TimeScale", "l") TimeBaseFlags = Type("TimeBaseFlags", "l") @@ -38,12 +88,13 @@ dataRefAttributesFlags = Type("dataRefAttributesFlags", "l") playHintsEnum = Type("playHintsEnum", "l") mediaHandlerFlagsEnum = Type("mediaHandlerFlagsEnum", "l") - -RgnHandle = OpaqueByValueType("RgnHandle", "ResObj") -PicHandle = OpaqueByValueType("PicHandle", "ResObj") +ComponentResult = Type("ComponentResult", "l") +HandlerError = Type("HandlerError", "l") +Ptr = InputOnlyType("Ptr", "s") +StringPtr = InputOnlyType("StringPtr", "s") -class MyObjectDefinition(GlobalObjectDefinition): +class MovieObjectDefinition(GlobalObjectDefinition): def outputCheckNewArg(self): Output("""if (itself == NULL) { PyErr_SetString(Qt_Error,"Cannot create null Movie"); @@ -52,26 +103,79 @@ def outputCheckNewArg(self): def outputFreeIt(self, itselfname): Output("DisposeMovie(%s);", itselfname) +class TrackObjectDefinition(GlobalObjectDefinition): + def outputCheckNewArg(self): + Output("""if (itself == NULL) { + PyErr_SetString(Qt_Error,"Cannot create null Track"); + return NULL; + }""") + def outputFreeIt(self, itselfname): + Output("DisposeMovieTrack(%s);", itselfname) + +class MediaObjectDefinition(GlobalObjectDefinition): + def outputCheckNewArg(self): + Output("""if (itself == NULL) { + PyErr_SetString(Qt_Error,"Cannot create null Media"); + return NULL; + }""") + def outputFreeIt(self, itselfname): + Output("DisposeTrackMedia(%s);", itselfname) + +class UserDataObjectDefinition(GlobalObjectDefinition): + def outputCheckNewArg(self): + Output("""if (itself == NULL) { + PyErr_SetString(Qt_Error,"Cannot create null UserData"); + return NULL; + }""") + def outputFreeIt(self, itselfname): + Output("DisposeUserData(%s);", itselfname) + +class TimeBaseObjectDefinition(GlobalObjectDefinition): + def outputCheckNewArg(self): + Output("""if (itself == NULL) { + PyErr_SetString(Qt_Error,"Cannot create null TimeBase"); + return NULL; + }""") + def outputFreeIt(self, itselfname): + Output("DisposeTimeBase(%s);", itselfname) + # From here on it's basically all boiler plate... # Create the generator groups and link them module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff) -object = MyObjectDefinition(OBJECTNAME, OBJECTPREFIX, OBJECTTYPE) -module.addobject(object) +Movie_object = MovieObjectDefinition('Movie', 'MovieObj', 'Movie') +Track_object = TrackObjectDefinition('Track', 'TrackObj', 'Track') +Media_object = MediaObjectDefinition('Media', 'MediaObj', 'Media') +UserData_object = UserDataObjectDefinition('UserData', 'UserDataObj', 'UserData') +TimeBase_object = TimeBaseObjectDefinition('TimeBase', 'TimeBaseObj', 'TimeBase') + +module.addobject(TimeBase_object) +module.addobject(UserData_object) +module.addobject(Media_object) +module.addobject(Track_object) +module.addobject(Movie_object) # Create the generator classes used to populate the lists -Function = FunctionGenerator -Method = MethodGenerator +Function = OSErrFunctionGenerator +Method = OSErrMethodGenerator # Create and populate the lists functions = [] -methods = [] +TimeBase_methods = [] +UserData_methods = [] +Media_methods = [] +Track_methods = [] +Movie_methods = [] execfile(INPUTFILE) # 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 methods: 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) +for f in Track_methods: Track_object.add(f) +for f in Movie_methods: Movie_object.add(f) # generate output (open the output file as late as possible) SetOutputFileName(OUTPUTFILE)