| |
| /* =========================== Module _Qt =========================== */ |
| |
| #include "Python.h" |
| |
| |
| |
| #include "pymactoolbox.h" |
| |
| /* Macro to test whether a weak-loaded CFM function exists */ |
| #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ |
| PyErr_SetString(PyExc_NotImplementedError, \ |
| "Not available in this shared library/OS version"); \ |
| return NULL; \ |
| }} while(0) |
| |
| |
| #include <QuickTime/QuickTime.h> |
| |
| |
| #ifdef USE_TOOLBOX_OBJECT_GLUE |
| extern PyObject *_TrackObj_New(Track); |
| extern int _TrackObj_Convert(PyObject *, Track *); |
| extern PyObject *_MovieObj_New(Movie); |
| extern int _MovieObj_Convert(PyObject *, Movie *); |
| extern PyObject *_MovieCtlObj_New(MovieController); |
| extern int _MovieCtlObj_Convert(PyObject *, MovieController *); |
| extern PyObject *_TimeBaseObj_New(TimeBase); |
| extern int _TimeBaseObj_Convert(PyObject *, TimeBase *); |
| extern PyObject *_UserDataObj_New(UserData); |
| extern int _UserDataObj_Convert(PyObject *, UserData *); |
| extern PyObject *_MediaObj_New(Media); |
| extern int _MediaObj_Convert(PyObject *, Media *); |
| |
| #define TrackObj_New _TrackObj_New |
| #define TrackObj_Convert _TrackObj_Convert |
| #define MovieObj_New _MovieObj_New |
| #define MovieObj_Convert _MovieObj_Convert |
| #define MovieCtlObj_New _MovieCtlObj_New |
| #define MovieCtlObj_Convert _MovieCtlObj_Convert |
| #define TimeBaseObj_New _TimeBaseObj_New |
| #define TimeBaseObj_Convert _TimeBaseObj_Convert |
| #define UserDataObj_New _UserDataObj_New |
| #define UserDataObj_Convert _UserDataObj_Convert |
| #define MediaObj_New _MediaObj_New |
| #define MediaObj_Convert _MediaObj_Convert |
| #endif |
| |
| /* Macro to allow us to GetNextInterestingTime without duration */ |
| #define GetMediaNextInterestingTimeOnly(media, flags, time, rate, rv) GetMediaNextInterestingTime(media, flags, time, rate, rv, NULL) |
| |
| /* |
| ** Parse/generate time records |
| */ |
| static PyObject * |
| QtTimeRecord_New(TimeRecord *itself) |
| { |
| if (itself->base) |
| return Py_BuildValue("O&lO&", PyMac_Buildwide, &itself->value, itself->scale, |
| TimeBaseObj_New, itself->base); |
| else |
| return Py_BuildValue("O&lO", PyMac_Buildwide, &itself->value, itself->scale, |
| Py_None); |
| } |
| |
| static int |
| QtTimeRecord_Convert(PyObject *v, TimeRecord *p_itself) |
| { |
| PyObject *base = NULL; |
| if( !PyArg_ParseTuple(v, "O&l|O", PyMac_Getwide, &p_itself->value, &p_itself->scale, |
| &base) ) |
| return 0; |
| if ( base == NULL || base == Py_None ) |
| p_itself->base = NULL; |
| else |
| if ( !TimeBaseObj_Convert(base, &p_itself->base) ) |
| return 0; |
| return 1; |
| } |
| |
| |
| |
| |
| static PyObject *Qt_Error; |
| |
| /* ------------------ Object type MovieController ------------------- */ |
| |
| PyTypeObject MovieController_Type; |
| |
| #define MovieCtlObj_Check(x) ((x)->ob_type == &MovieController_Type || PyObject_TypeCheck((x), &MovieController_Type)) |
| |
| typedef struct MovieControllerObject { |
| PyObject_HEAD |
| MovieController ob_itself; |
| } MovieControllerObject; |
| |
| PyObject *MovieCtlObj_New(MovieController itself) |
| { |
| MovieControllerObject *it; |
| if (itself == NULL) { |
| PyErr_SetString(Qt_Error,"Cannot create null MovieController"); |
| return NULL; |
| } |
| it = PyObject_NEW(MovieControllerObject, &MovieController_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| return (PyObject *)it; |
| } |
| int MovieCtlObj_Convert(PyObject *v, MovieController *p_itself) |
| { |
| if (!MovieCtlObj_Check(v)) |
| { |
| PyErr_SetString(PyExc_TypeError, "MovieController required"); |
| return 0; |
| } |
| *p_itself = ((MovieControllerObject *)v)->ob_itself; |
| return 1; |
| } |
| |
| static void MovieCtlObj_dealloc(MovieControllerObject *self) |
| { |
| DisposeMovieController(self->ob_itself); |
| self->ob_type->tp_free((PyObject *)self); |
| } |
| |
| static PyObject *MovieCtlObj_MCSetMovie(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Movie theMovie; |
| WindowPtr movieWindow; |
| Point where; |
| #ifndef MCSetMovie |
| PyMac_PRECHECK(MCSetMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&", |
| MovieObj_Convert, &theMovie, |
| WinObj_Convert, &movieWindow, |
| PyMac_GetPoint, &where)) |
| return NULL; |
| _rv = MCSetMovie(_self->ob_itself, |
| theMovie, |
| movieWindow, |
| where); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetIndMovie(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| short index; |
| #ifndef MCGetIndMovie |
| PyMac_PRECHECK(MCGetIndMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &index)) |
| return NULL; |
| _rv = MCGetIndMovie(_self->ob_itself, |
| index); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCRemoveAllMovies(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| #ifndef MCRemoveAllMovies |
| PyMac_PRECHECK(MCRemoveAllMovies); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCRemoveAllMovies(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCRemoveAMovie(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Movie m; |
| #ifndef MCRemoveAMovie |
| PyMac_PRECHECK(MCRemoveAMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| MovieObj_Convert, &m)) |
| return NULL; |
| _rv = MCRemoveAMovie(_self->ob_itself, |
| m); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCRemoveMovie(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| #ifndef MCRemoveMovie |
| PyMac_PRECHECK(MCRemoveMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCRemoveMovie(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCIsPlayerEvent(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| EventRecord e; |
| #ifndef MCIsPlayerEvent |
| PyMac_PRECHECK(MCIsPlayerEvent); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetEventRecord, &e)) |
| return NULL; |
| _rv = MCIsPlayerEvent(_self->ob_itself, |
| &e); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCDoAction(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| short action; |
| void * params; |
| #ifndef MCDoAction |
| PyMac_PRECHECK(MCDoAction); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hs", |
| &action, |
| ¶ms)) |
| return NULL; |
| _rv = MCDoAction(_self->ob_itself, |
| action, |
| params); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCSetControllerAttached(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Boolean attach; |
| #ifndef MCSetControllerAttached |
| PyMac_PRECHECK(MCSetControllerAttached); |
| #endif |
| if (!PyArg_ParseTuple(_args, "b", |
| &attach)) |
| return NULL; |
| _rv = MCSetControllerAttached(_self->ob_itself, |
| attach); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCIsControllerAttached(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| #ifndef MCIsControllerAttached |
| PyMac_PRECHECK(MCIsControllerAttached); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCIsControllerAttached(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCSetControllerPort(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| CGrafPtr gp; |
| #ifndef MCSetControllerPort |
| PyMac_PRECHECK(MCSetControllerPort); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| GrafObj_Convert, &gp)) |
| return NULL; |
| _rv = MCSetControllerPort(_self->ob_itself, |
| gp); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetControllerPort(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| CGrafPtr _rv; |
| #ifndef MCGetControllerPort |
| PyMac_PRECHECK(MCGetControllerPort); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCGetControllerPort(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| GrafObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCSetVisible(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Boolean visible; |
| #ifndef MCSetVisible |
| PyMac_PRECHECK(MCSetVisible); |
| #endif |
| if (!PyArg_ParseTuple(_args, "b", |
| &visible)) |
| return NULL; |
| _rv = MCSetVisible(_self->ob_itself, |
| visible); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetVisible(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| #ifndef MCGetVisible |
| PyMac_PRECHECK(MCGetVisible); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCGetVisible(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetControllerBoundsRect(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Rect bounds; |
| #ifndef MCGetControllerBoundsRect |
| PyMac_PRECHECK(MCGetControllerBoundsRect); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCGetControllerBoundsRect(_self->ob_itself, |
| &bounds); |
| _res = Py_BuildValue("lO&", |
| _rv, |
| PyMac_BuildRect, &bounds); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCSetControllerBoundsRect(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Rect bounds; |
| #ifndef MCSetControllerBoundsRect |
| PyMac_PRECHECK(MCSetControllerBoundsRect); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetRect, &bounds)) |
| return NULL; |
| _rv = MCSetControllerBoundsRect(_self->ob_itself, |
| &bounds); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetControllerBoundsRgn(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| #ifndef MCGetControllerBoundsRgn |
| PyMac_PRECHECK(MCGetControllerBoundsRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCGetControllerBoundsRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetWindowRgn(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| WindowPtr w; |
| #ifndef MCGetWindowRgn |
| PyMac_PRECHECK(MCGetWindowRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &w)) |
| return NULL; |
| _rv = MCGetWindowRgn(_self->ob_itself, |
| w); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCMovieChanged(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Movie m; |
| #ifndef MCMovieChanged |
| PyMac_PRECHECK(MCMovieChanged); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| MovieObj_Convert, &m)) |
| return NULL; |
| _rv = MCMovieChanged(_self->ob_itself, |
| m); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCSetDuration(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| TimeValue duration; |
| #ifndef MCSetDuration |
| PyMac_PRECHECK(MCSetDuration); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &duration)) |
| return NULL; |
| _rv = MCSetDuration(_self->ob_itself, |
| duration); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetCurrentTime(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| TimeScale scale; |
| #ifndef MCGetCurrentTime |
| PyMac_PRECHECK(MCGetCurrentTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCGetCurrentTime(_self->ob_itself, |
| &scale); |
| _res = Py_BuildValue("ll", |
| _rv, |
| scale); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCNewAttachedController(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Movie theMovie; |
| WindowPtr w; |
| Point where; |
| #ifndef MCNewAttachedController |
| PyMac_PRECHECK(MCNewAttachedController); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&", |
| MovieObj_Convert, &theMovie, |
| WinObj_Convert, &w, |
| PyMac_GetPoint, &where)) |
| return NULL; |
| _rv = MCNewAttachedController(_self->ob_itself, |
| theMovie, |
| w, |
| where); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCDraw(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| WindowPtr w; |
| #ifndef MCDraw |
| PyMac_PRECHECK(MCDraw); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &w)) |
| return NULL; |
| _rv = MCDraw(_self->ob_itself, |
| w); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCActivate(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| WindowPtr w; |
| Boolean activate; |
| #ifndef MCActivate |
| PyMac_PRECHECK(MCActivate); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&b", |
| WinObj_Convert, &w, |
| &activate)) |
| return NULL; |
| _rv = MCActivate(_self->ob_itself, |
| w, |
| activate); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCIdle(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| #ifndef MCIdle |
| PyMac_PRECHECK(MCIdle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCIdle(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCKey(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| SInt8 key; |
| long modifiers; |
| #ifndef MCKey |
| PyMac_PRECHECK(MCKey); |
| #endif |
| if (!PyArg_ParseTuple(_args, "bl", |
| &key, |
| &modifiers)) |
| return NULL; |
| _rv = MCKey(_self->ob_itself, |
| key, |
| modifiers); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCClick(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| WindowPtr w; |
| Point where; |
| long when; |
| long modifiers; |
| #ifndef MCClick |
| PyMac_PRECHECK(MCClick); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&ll", |
| WinObj_Convert, &w, |
| PyMac_GetPoint, &where, |
| &when, |
| &modifiers)) |
| return NULL; |
| _rv = MCClick(_self->ob_itself, |
| w, |
| where, |
| when, |
| modifiers); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCEnableEditing(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Boolean enabled; |
| #ifndef MCEnableEditing |
| PyMac_PRECHECK(MCEnableEditing); |
| #endif |
| if (!PyArg_ParseTuple(_args, "b", |
| &enabled)) |
| return NULL; |
| _rv = MCEnableEditing(_self->ob_itself, |
| enabled); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCIsEditingEnabled(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| #ifndef MCIsEditingEnabled |
| PyMac_PRECHECK(MCIsEditingEnabled); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCIsEditingEnabled(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCCopy(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| #ifndef MCCopy |
| PyMac_PRECHECK(MCCopy); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCCopy(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCCut(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| #ifndef MCCut |
| PyMac_PRECHECK(MCCut); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCCut(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCPaste(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Movie srcMovie; |
| #ifndef MCPaste |
| PyMac_PRECHECK(MCPaste); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| MovieObj_Convert, &srcMovie)) |
| return NULL; |
| _rv = MCPaste(_self->ob_itself, |
| srcMovie); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCClear(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| #ifndef MCClear |
| PyMac_PRECHECK(MCClear); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCClear(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCUndo(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| #ifndef MCUndo |
| PyMac_PRECHECK(MCUndo); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCUndo(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCPositionController(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Rect movieRect; |
| Rect controllerRect; |
| long someFlags; |
| #ifndef MCPositionController |
| PyMac_PRECHECK(MCPositionController); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&l", |
| PyMac_GetRect, &movieRect, |
| PyMac_GetRect, &controllerRect, |
| &someFlags)) |
| return NULL; |
| _rv = MCPositionController(_self->ob_itself, |
| &movieRect, |
| &controllerRect, |
| someFlags); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetControllerInfo(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| long someFlags; |
| #ifndef MCGetControllerInfo |
| PyMac_PRECHECK(MCGetControllerInfo); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCGetControllerInfo(_self->ob_itself, |
| &someFlags); |
| _res = Py_BuildValue("ll", |
| _rv, |
| someFlags); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCSetClip(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| RgnHandle theClip; |
| RgnHandle movieClip; |
| #ifndef MCSetClip |
| PyMac_PRECHECK(MCSetClip); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| ResObj_Convert, &theClip, |
| ResObj_Convert, &movieClip)) |
| return NULL; |
| _rv = MCSetClip(_self->ob_itself, |
| theClip, |
| movieClip); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetClip(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| RgnHandle theClip; |
| RgnHandle movieClip; |
| #ifndef MCGetClip |
| PyMac_PRECHECK(MCGetClip); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCGetClip(_self->ob_itself, |
| &theClip, |
| &movieClip); |
| _res = Py_BuildValue("lO&O&", |
| _rv, |
| ResObj_New, theClip, |
| ResObj_New, movieClip); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCDrawBadge(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| RgnHandle movieRgn; |
| RgnHandle badgeRgn; |
| #ifndef MCDrawBadge |
| PyMac_PRECHECK(MCDrawBadge); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &movieRgn)) |
| return NULL; |
| _rv = MCDrawBadge(_self->ob_itself, |
| movieRgn, |
| &badgeRgn); |
| _res = Py_BuildValue("lO&", |
| _rv, |
| ResObj_New, badgeRgn); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCSetUpEditMenu(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| long modifiers; |
| MenuHandle mh; |
| #ifndef MCSetUpEditMenu |
| PyMac_PRECHECK(MCSetUpEditMenu); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lO&", |
| &modifiers, |
| MenuObj_Convert, &mh)) |
| return NULL; |
| _rv = MCSetUpEditMenu(_self->ob_itself, |
| modifiers, |
| mh); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetMenuString(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| long modifiers; |
| short item; |
| Str255 aString; |
| #ifndef MCGetMenuString |
| PyMac_PRECHECK(MCGetMenuString); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lhO&", |
| &modifiers, |
| &item, |
| PyMac_GetStr255, aString)) |
| return NULL; |
| _rv = MCGetMenuString(_self->ob_itself, |
| modifiers, |
| item, |
| aString); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCPtInController(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Point thePt; |
| Boolean inController; |
| #ifndef MCPtInController |
| PyMac_PRECHECK(MCPtInController); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetPoint, &thePt)) |
| return NULL; |
| _rv = MCPtInController(_self->ob_itself, |
| thePt, |
| &inController); |
| _res = Py_BuildValue("lb", |
| _rv, |
| inController); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCInvalidate(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| WindowPtr w; |
| RgnHandle invalidRgn; |
| #ifndef MCInvalidate |
| PyMac_PRECHECK(MCInvalidate); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| WinObj_Convert, &w, |
| ResObj_Convert, &invalidRgn)) |
| return NULL; |
| _rv = MCInvalidate(_self->ob_itself, |
| w, |
| invalidRgn); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCAdjustCursor(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| WindowPtr w; |
| Point where; |
| long modifiers; |
| #ifndef MCAdjustCursor |
| PyMac_PRECHECK(MCAdjustCursor); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&l", |
| WinObj_Convert, &w, |
| PyMac_GetPoint, &where, |
| &modifiers)) |
| return NULL; |
| _rv = MCAdjustCursor(_self->ob_itself, |
| w, |
| where, |
| modifiers); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetInterfaceElement(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MCInterfaceElement whichElement; |
| void * element; |
| #ifndef MCGetInterfaceElement |
| PyMac_PRECHECK(MCGetInterfaceElement); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ls", |
| &whichElement, |
| &element)) |
| return NULL; |
| _rv = MCGetInterfaceElement(_self->ob_itself, |
| whichElement, |
| element); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCAddMovieSegment(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Movie srcMovie; |
| Boolean scaled; |
| #ifndef MCAddMovieSegment |
| PyMac_PRECHECK(MCAddMovieSegment); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&b", |
| MovieObj_Convert, &srcMovie, |
| &scaled)) |
| return NULL; |
| _rv = MCAddMovieSegment(_self->ob_itself, |
| srcMovie, |
| scaled); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCTrimMovieSegment(MovieControllerObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| #ifndef MCTrimMovieSegment |
| PyMac_PRECHECK(MCTrimMovieSegment); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCTrimMovieSegment(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyMethodDef MovieCtlObj_methods[] = { |
| {"MCSetMovie", (PyCFunction)MovieCtlObj_MCSetMovie, 1, |
| PyDoc_STR("(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)")}, |
| {"MCGetIndMovie", (PyCFunction)MovieCtlObj_MCGetIndMovie, 1, |
| PyDoc_STR("(short index) -> (Movie _rv)")}, |
| {"MCRemoveAllMovies", (PyCFunction)MovieCtlObj_MCRemoveAllMovies, 1, |
| PyDoc_STR("() -> (ComponentResult _rv)")}, |
| {"MCRemoveAMovie", (PyCFunction)MovieCtlObj_MCRemoveAMovie, 1, |
| PyDoc_STR("(Movie m) -> (ComponentResult _rv)")}, |
| {"MCRemoveMovie", (PyCFunction)MovieCtlObj_MCRemoveMovie, 1, |
| PyDoc_STR("() -> (ComponentResult _rv)")}, |
| {"MCIsPlayerEvent", (PyCFunction)MovieCtlObj_MCIsPlayerEvent, 1, |
| PyDoc_STR("(EventRecord e) -> (ComponentResult _rv)")}, |
| {"MCDoAction", (PyCFunction)MovieCtlObj_MCDoAction, 1, |
| PyDoc_STR("(short action, void * params) -> (ComponentResult _rv)")}, |
| {"MCSetControllerAttached", (PyCFunction)MovieCtlObj_MCSetControllerAttached, 1, |
| PyDoc_STR("(Boolean attach) -> (ComponentResult _rv)")}, |
| {"MCIsControllerAttached", (PyCFunction)MovieCtlObj_MCIsControllerAttached, 1, |
| PyDoc_STR("() -> (ComponentResult _rv)")}, |
| {"MCSetControllerPort", (PyCFunction)MovieCtlObj_MCSetControllerPort, 1, |
| PyDoc_STR("(CGrafPtr gp) -> (ComponentResult _rv)")}, |
| {"MCGetControllerPort", (PyCFunction)MovieCtlObj_MCGetControllerPort, 1, |
| PyDoc_STR("() -> (CGrafPtr _rv)")}, |
| {"MCSetVisible", (PyCFunction)MovieCtlObj_MCSetVisible, 1, |
| PyDoc_STR("(Boolean visible) -> (ComponentResult _rv)")}, |
| {"MCGetVisible", (PyCFunction)MovieCtlObj_MCGetVisible, 1, |
| PyDoc_STR("() -> (ComponentResult _rv)")}, |
| {"MCGetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRect, 1, |
| PyDoc_STR("() -> (ComponentResult _rv, Rect bounds)")}, |
| {"MCSetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCSetControllerBoundsRect, 1, |
| PyDoc_STR("(Rect bounds) -> (ComponentResult _rv)")}, |
| {"MCGetControllerBoundsRgn", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRgn, 1, |
| PyDoc_STR("() -> (RgnHandle _rv)")}, |
| {"MCGetWindowRgn", (PyCFunction)MovieCtlObj_MCGetWindowRgn, 1, |
| PyDoc_STR("(WindowPtr w) -> (RgnHandle _rv)")}, |
| {"MCMovieChanged", (PyCFunction)MovieCtlObj_MCMovieChanged, 1, |
| PyDoc_STR("(Movie m) -> (ComponentResult _rv)")}, |
| {"MCSetDuration", (PyCFunction)MovieCtlObj_MCSetDuration, 1, |
| PyDoc_STR("(TimeValue duration) -> (ComponentResult _rv)")}, |
| {"MCGetCurrentTime", (PyCFunction)MovieCtlObj_MCGetCurrentTime, 1, |
| PyDoc_STR("() -> (TimeValue _rv, TimeScale scale)")}, |
| {"MCNewAttachedController", (PyCFunction)MovieCtlObj_MCNewAttachedController, 1, |
| PyDoc_STR("(Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)")}, |
| {"MCDraw", (PyCFunction)MovieCtlObj_MCDraw, 1, |
| PyDoc_STR("(WindowPtr w) -> (ComponentResult _rv)")}, |
| {"MCActivate", (PyCFunction)MovieCtlObj_MCActivate, 1, |
| PyDoc_STR("(WindowPtr w, Boolean activate) -> (ComponentResult _rv)")}, |
| {"MCIdle", (PyCFunction)MovieCtlObj_MCIdle, 1, |
| PyDoc_STR("() -> (ComponentResult _rv)")}, |
| {"MCKey", (PyCFunction)MovieCtlObj_MCKey, 1, |
| PyDoc_STR("(SInt8 key, long modifiers) -> (ComponentResult _rv)")}, |
| {"MCClick", (PyCFunction)MovieCtlObj_MCClick, 1, |
| PyDoc_STR("(WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)")}, |
| {"MCEnableEditing", (PyCFunction)MovieCtlObj_MCEnableEditing, 1, |
| PyDoc_STR("(Boolean enabled) -> (ComponentResult _rv)")}, |
| {"MCIsEditingEnabled", (PyCFunction)MovieCtlObj_MCIsEditingEnabled, 1, |
| PyDoc_STR("() -> (long _rv)")}, |
| {"MCCopy", (PyCFunction)MovieCtlObj_MCCopy, 1, |
| PyDoc_STR("() -> (Movie _rv)")}, |
| {"MCCut", (PyCFunction)MovieCtlObj_MCCut, 1, |
| PyDoc_STR("() -> (Movie _rv)")}, |
| {"MCPaste", (PyCFunction)MovieCtlObj_MCPaste, 1, |
| PyDoc_STR("(Movie srcMovie) -> (ComponentResult _rv)")}, |
| {"MCClear", (PyCFunction)MovieCtlObj_MCClear, 1, |
| PyDoc_STR("() -> (ComponentResult _rv)")}, |
| {"MCUndo", (PyCFunction)MovieCtlObj_MCUndo, 1, |
| PyDoc_STR("() -> (ComponentResult _rv)")}, |
| {"MCPositionController", (PyCFunction)MovieCtlObj_MCPositionController, 1, |
| PyDoc_STR("(Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)")}, |
| {"MCGetControllerInfo", (PyCFunction)MovieCtlObj_MCGetControllerInfo, 1, |
| PyDoc_STR("() -> (ComponentResult _rv, long someFlags)")}, |
| {"MCSetClip", (PyCFunction)MovieCtlObj_MCSetClip, 1, |
| PyDoc_STR("(RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)")}, |
| {"MCGetClip", (PyCFunction)MovieCtlObj_MCGetClip, 1, |
| PyDoc_STR("() -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)")}, |
| {"MCDrawBadge", (PyCFunction)MovieCtlObj_MCDrawBadge, 1, |
| PyDoc_STR("(RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)")}, |
| {"MCSetUpEditMenu", (PyCFunction)MovieCtlObj_MCSetUpEditMenu, 1, |
| PyDoc_STR("(long modifiers, MenuHandle mh) -> (ComponentResult _rv)")}, |
| {"MCGetMenuString", (PyCFunction)MovieCtlObj_MCGetMenuString, 1, |
| PyDoc_STR("(long modifiers, short item, Str255 aString) -> (ComponentResult _rv)")}, |
| {"MCPtInController", (PyCFunction)MovieCtlObj_MCPtInController, 1, |
| PyDoc_STR("(Point thePt) -> (ComponentResult _rv, Boolean inController)")}, |
| {"MCInvalidate", (PyCFunction)MovieCtlObj_MCInvalidate, 1, |
| PyDoc_STR("(WindowPtr w, RgnHandle invalidRgn) -> (ComponentResult _rv)")}, |
| {"MCAdjustCursor", (PyCFunction)MovieCtlObj_MCAdjustCursor, 1, |
| PyDoc_STR("(WindowPtr w, Point where, long modifiers) -> (ComponentResult _rv)")}, |
| {"MCGetInterfaceElement", (PyCFunction)MovieCtlObj_MCGetInterfaceElement, 1, |
| PyDoc_STR("(MCInterfaceElement whichElement, void * element) -> (ComponentResult _rv)")}, |
| {"MCAddMovieSegment", (PyCFunction)MovieCtlObj_MCAddMovieSegment, 1, |
| PyDoc_STR("(Movie srcMovie, Boolean scaled) -> (ComponentResult _rv)")}, |
| {"MCTrimMovieSegment", (PyCFunction)MovieCtlObj_MCTrimMovieSegment, 1, |
| PyDoc_STR("() -> (ComponentResult _rv)")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define MovieCtlObj_getsetlist NULL |
| |
| |
| #define MovieCtlObj_compare NULL |
| |
| #define MovieCtlObj_repr NULL |
| |
| #define MovieCtlObj_hash NULL |
| #define MovieCtlObj_tp_init 0 |
| |
| #define MovieCtlObj_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *MovieCtlObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) |
| { |
| PyObject *self; |
| MovieController itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, MovieCtlObj_Convert, &itself)) return NULL; |
| if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((MovieControllerObject *)self)->ob_itself = itself; |
| return self; |
| } |
| |
| #define MovieCtlObj_tp_free PyObject_Del |
| |
| |
| PyTypeObject MovieController_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_Qt.MovieController", /*tp_name*/ |
| sizeof(MovieControllerObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) MovieCtlObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*tp_setattr*/ |
| (cmpfunc) MovieCtlObj_compare, /*tp_compare*/ |
| (reprfunc) MovieCtlObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) MovieCtlObj_hash, /*tp_hash*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| MovieCtlObj_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| MovieCtlObj_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| MovieCtlObj_tp_init, /* tp_init */ |
| MovieCtlObj_tp_alloc, /* tp_alloc */ |
| MovieCtlObj_tp_new, /* tp_new */ |
| MovieCtlObj_tp_free, /* tp_free */ |
| }; |
| |
| /* ---------------- End object type MovieController ----------------- */ |
| |
| |
| /* ---------------------- Object type TimeBase ---------------------- */ |
| |
| PyTypeObject TimeBase_Type; |
| |
| #define TimeBaseObj_Check(x) ((x)->ob_type == &TimeBase_Type || PyObject_TypeCheck((x), &TimeBase_Type)) |
| |
| typedef struct TimeBaseObject { |
| PyObject_HEAD |
| TimeBase ob_itself; |
| } TimeBaseObject; |
| |
| PyObject *TimeBaseObj_New(TimeBase itself) |
| { |
| TimeBaseObject *it; |
| if (itself == NULL) { |
| PyErr_SetString(Qt_Error,"Cannot create null TimeBase"); |
| return NULL; |
| } |
| it = PyObject_NEW(TimeBaseObject, &TimeBase_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| return (PyObject *)it; |
| } |
| int TimeBaseObj_Convert(PyObject *v, TimeBase *p_itself) |
| { |
| if (!TimeBaseObj_Check(v)) |
| { |
| PyErr_SetString(PyExc_TypeError, "TimeBase required"); |
| return 0; |
| } |
| *p_itself = ((TimeBaseObject *)v)->ob_itself; |
| return 1; |
| } |
| |
| static void TimeBaseObj_dealloc(TimeBaseObject *self) |
| { |
| /* Cleanup of self->ob_itself goes here */ |
| self->ob_type->tp_free((PyObject *)self); |
| } |
| |
| static PyObject *TimeBaseObj_DisposeTimeBase(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef DisposeTimeBase |
| PyMac_PRECHECK(DisposeTimeBase); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| DisposeTimeBase(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_GetTimeBaseTime(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| TimeScale s; |
| TimeRecord tr; |
| #ifndef GetTimeBaseTime |
| PyMac_PRECHECK(GetTimeBaseTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &s)) |
| return NULL; |
| _rv = GetTimeBaseTime(_self->ob_itself, |
| s, |
| &tr); |
| _res = Py_BuildValue("lO&", |
| _rv, |
| QtTimeRecord_New, &tr); |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_SetTimeBaseTime(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeRecord tr; |
| #ifndef SetTimeBaseTime |
| PyMac_PRECHECK(SetTimeBaseTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| QtTimeRecord_Convert, &tr)) |
| return NULL; |
| SetTimeBaseTime(_self->ob_itself, |
| &tr); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_SetTimeBaseValue(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue t; |
| TimeScale s; |
| #ifndef SetTimeBaseValue |
| PyMac_PRECHECK(SetTimeBaseValue); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &t, |
| &s)) |
| return NULL; |
| SetTimeBaseValue(_self->ob_itself, |
| t, |
| s); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_GetTimeBaseRate(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Fixed _rv; |
| #ifndef GetTimeBaseRate |
| PyMac_PRECHECK(GetTimeBaseRate); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTimeBaseRate(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildFixed, _rv); |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_SetTimeBaseRate(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Fixed r; |
| #ifndef SetTimeBaseRate |
| PyMac_PRECHECK(SetTimeBaseRate); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetFixed, &r)) |
| return NULL; |
| SetTimeBaseRate(_self->ob_itself, |
| r); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_GetTimeBaseStartTime(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| TimeScale s; |
| TimeRecord tr; |
| #ifndef GetTimeBaseStartTime |
| PyMac_PRECHECK(GetTimeBaseStartTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &s)) |
| return NULL; |
| _rv = GetTimeBaseStartTime(_self->ob_itself, |
| s, |
| &tr); |
| _res = Py_BuildValue("lO&", |
| _rv, |
| QtTimeRecord_New, &tr); |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_SetTimeBaseStartTime(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeRecord tr; |
| #ifndef SetTimeBaseStartTime |
| PyMac_PRECHECK(SetTimeBaseStartTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| QtTimeRecord_Convert, &tr)) |
| return NULL; |
| SetTimeBaseStartTime(_self->ob_itself, |
| &tr); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_GetTimeBaseStopTime(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| TimeScale s; |
| TimeRecord tr; |
| #ifndef GetTimeBaseStopTime |
| PyMac_PRECHECK(GetTimeBaseStopTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &s)) |
| return NULL; |
| _rv = GetTimeBaseStopTime(_self->ob_itself, |
| s, |
| &tr); |
| _res = Py_BuildValue("lO&", |
| _rv, |
| QtTimeRecord_New, &tr); |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_SetTimeBaseStopTime(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeRecord tr; |
| #ifndef SetTimeBaseStopTime |
| PyMac_PRECHECK(SetTimeBaseStopTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| QtTimeRecord_Convert, &tr)) |
| return NULL; |
| SetTimeBaseStopTime(_self->ob_itself, |
| &tr); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_GetTimeBaseFlags(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| #ifndef GetTimeBaseFlags |
| PyMac_PRECHECK(GetTimeBaseFlags); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTimeBaseFlags(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_SetTimeBaseFlags(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long timeBaseFlags; |
| #ifndef SetTimeBaseFlags |
| PyMac_PRECHECK(SetTimeBaseFlags); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &timeBaseFlags)) |
| return NULL; |
| SetTimeBaseFlags(_self->ob_itself, |
| timeBaseFlags); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_SetTimeBaseMasterTimeBase(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeBase master; |
| TimeRecord slaveZero; |
| #ifndef SetTimeBaseMasterTimeBase |
| PyMac_PRECHECK(SetTimeBaseMasterTimeBase); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| TimeBaseObj_Convert, &master, |
| QtTimeRecord_Convert, &slaveZero)) |
| return NULL; |
| SetTimeBaseMasterTimeBase(_self->ob_itself, |
| master, |
| &slaveZero); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_GetTimeBaseMasterTimeBase(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeBase _rv; |
| #ifndef GetTimeBaseMasterTimeBase |
| PyMac_PRECHECK(GetTimeBaseMasterTimeBase); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTimeBaseMasterTimeBase(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| TimeBaseObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_SetTimeBaseMasterClock(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Component clockMeister; |
| TimeRecord slaveZero; |
| #ifndef SetTimeBaseMasterClock |
| PyMac_PRECHECK(SetTimeBaseMasterClock); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| CmpObj_Convert, &clockMeister, |
| QtTimeRecord_Convert, &slaveZero)) |
| return NULL; |
| SetTimeBaseMasterClock(_self->ob_itself, |
| clockMeister, |
| &slaveZero); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_GetTimeBaseMasterClock(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentInstance _rv; |
| #ifndef GetTimeBaseMasterClock |
| PyMac_PRECHECK(GetTimeBaseMasterClock); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTimeBaseMasterClock(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| CmpInstObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_GetTimeBaseStatus(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| TimeRecord unpinnedTime; |
| #ifndef GetTimeBaseStatus |
| PyMac_PRECHECK(GetTimeBaseStatus); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTimeBaseStatus(_self->ob_itself, |
| &unpinnedTime); |
| _res = Py_BuildValue("lO&", |
| _rv, |
| QtTimeRecord_New, &unpinnedTime); |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_SetTimeBaseZero(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeRecord zero; |
| #ifndef SetTimeBaseZero |
| PyMac_PRECHECK(SetTimeBaseZero); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| QtTimeRecord_Convert, &zero)) |
| return NULL; |
| SetTimeBaseZero(_self->ob_itself, |
| &zero); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_GetTimeBaseEffectiveRate(TimeBaseObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Fixed _rv; |
| #ifndef GetTimeBaseEffectiveRate |
| PyMac_PRECHECK(GetTimeBaseEffectiveRate); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTimeBaseEffectiveRate(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildFixed, _rv); |
| return _res; |
| } |
| |
| static PyMethodDef TimeBaseObj_methods[] = { |
| {"DisposeTimeBase", (PyCFunction)TimeBaseObj_DisposeTimeBase, 1, |
| PyDoc_STR("() -> None")}, |
| {"GetTimeBaseTime", (PyCFunction)TimeBaseObj_GetTimeBaseTime, 1, |
| PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")}, |
| {"SetTimeBaseTime", (PyCFunction)TimeBaseObj_SetTimeBaseTime, 1, |
| PyDoc_STR("(TimeRecord tr) -> None")}, |
| {"SetTimeBaseValue", (PyCFunction)TimeBaseObj_SetTimeBaseValue, 1, |
| PyDoc_STR("(TimeValue t, TimeScale s) -> None")}, |
| {"GetTimeBaseRate", (PyCFunction)TimeBaseObj_GetTimeBaseRate, 1, |
| PyDoc_STR("() -> (Fixed _rv)")}, |
| {"SetTimeBaseRate", (PyCFunction)TimeBaseObj_SetTimeBaseRate, 1, |
| PyDoc_STR("(Fixed r) -> None")}, |
| {"GetTimeBaseStartTime", (PyCFunction)TimeBaseObj_GetTimeBaseStartTime, 1, |
| PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")}, |
| {"SetTimeBaseStartTime", (PyCFunction)TimeBaseObj_SetTimeBaseStartTime, 1, |
| PyDoc_STR("(TimeRecord tr) -> None")}, |
| {"GetTimeBaseStopTime", (PyCFunction)TimeBaseObj_GetTimeBaseStopTime, 1, |
| PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")}, |
| {"SetTimeBaseStopTime", (PyCFunction)TimeBaseObj_SetTimeBaseStopTime, 1, |
| PyDoc_STR("(TimeRecord tr) -> None")}, |
| {"GetTimeBaseFlags", (PyCFunction)TimeBaseObj_GetTimeBaseFlags, 1, |
| PyDoc_STR("() -> (long _rv)")}, |
| {"SetTimeBaseFlags", (PyCFunction)TimeBaseObj_SetTimeBaseFlags, 1, |
| PyDoc_STR("(long timeBaseFlags) -> None")}, |
| {"SetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_SetTimeBaseMasterTimeBase, 1, |
| PyDoc_STR("(TimeBase master, TimeRecord slaveZero) -> None")}, |
| {"GetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_GetTimeBaseMasterTimeBase, 1, |
| PyDoc_STR("() -> (TimeBase _rv)")}, |
| {"SetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_SetTimeBaseMasterClock, 1, |
| PyDoc_STR("(Component clockMeister, TimeRecord slaveZero) -> None")}, |
| {"GetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_GetTimeBaseMasterClock, 1, |
| PyDoc_STR("() -> (ComponentInstance _rv)")}, |
| {"GetTimeBaseStatus", (PyCFunction)TimeBaseObj_GetTimeBaseStatus, 1, |
| PyDoc_STR("() -> (long _rv, TimeRecord unpinnedTime)")}, |
| {"SetTimeBaseZero", (PyCFunction)TimeBaseObj_SetTimeBaseZero, 1, |
| PyDoc_STR("(TimeRecord zero) -> None")}, |
| {"GetTimeBaseEffectiveRate", (PyCFunction)TimeBaseObj_GetTimeBaseEffectiveRate, 1, |
| PyDoc_STR("() -> (Fixed _rv)")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define TimeBaseObj_getsetlist NULL |
| |
| |
| #define TimeBaseObj_compare NULL |
| |
| #define TimeBaseObj_repr NULL |
| |
| #define TimeBaseObj_hash NULL |
| #define TimeBaseObj_tp_init 0 |
| |
| #define TimeBaseObj_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *TimeBaseObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) |
| { |
| PyObject *self; |
| TimeBase itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, TimeBaseObj_Convert, &itself)) return NULL; |
| if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((TimeBaseObject *)self)->ob_itself = itself; |
| return self; |
| } |
| |
| #define TimeBaseObj_tp_free PyObject_Del |
| |
| |
| PyTypeObject TimeBase_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_Qt.TimeBase", /*tp_name*/ |
| sizeof(TimeBaseObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) TimeBaseObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*tp_setattr*/ |
| (cmpfunc) TimeBaseObj_compare, /*tp_compare*/ |
| (reprfunc) TimeBaseObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) TimeBaseObj_hash, /*tp_hash*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| TimeBaseObj_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| TimeBaseObj_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| TimeBaseObj_tp_init, /* tp_init */ |
| TimeBaseObj_tp_alloc, /* tp_alloc */ |
| TimeBaseObj_tp_new, /* tp_new */ |
| TimeBaseObj_tp_free, /* tp_free */ |
| }; |
| |
| /* -------------------- End object type TimeBase -------------------- */ |
| |
| |
| /* ---------------------- Object type UserData ---------------------- */ |
| |
| PyTypeObject UserData_Type; |
| |
| #define UserDataObj_Check(x) ((x)->ob_type == &UserData_Type || PyObject_TypeCheck((x), &UserData_Type)) |
| |
| typedef struct UserDataObject { |
| PyObject_HEAD |
| UserData ob_itself; |
| } UserDataObject; |
| |
| PyObject *UserDataObj_New(UserData itself) |
| { |
| UserDataObject *it; |
| if (itself == NULL) { |
| PyErr_SetString(Qt_Error,"Cannot create null UserData"); |
| return NULL; |
| } |
| it = PyObject_NEW(UserDataObject, &UserData_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| return (PyObject *)it; |
| } |
| int UserDataObj_Convert(PyObject *v, UserData *p_itself) |
| { |
| if (!UserDataObj_Check(v)) |
| { |
| PyErr_SetString(PyExc_TypeError, "UserData required"); |
| return 0; |
| } |
| *p_itself = ((UserDataObject *)v)->ob_itself; |
| return 1; |
| } |
| |
| static void UserDataObj_dealloc(UserDataObject *self) |
| { |
| DisposeUserData(self->ob_itself); |
| self->ob_type->tp_free((PyObject *)self); |
| } |
| |
| static PyObject *UserDataObj_GetUserData(UserDataObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle data; |
| OSType udType; |
| long index; |
| #ifndef GetUserData |
| PyMac_PRECHECK(GetUserData); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&l", |
| ResObj_Convert, &data, |
| PyMac_GetOSType, &udType, |
| &index)) |
| return NULL; |
| _err = GetUserData(_self->ob_itself, |
| data, |
| udType, |
| index); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_AddUserData(UserDataObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle data; |
| OSType udType; |
| #ifndef AddUserData |
| PyMac_PRECHECK(AddUserData); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| ResObj_Convert, &data, |
| PyMac_GetOSType, &udType)) |
| return NULL; |
| _err = AddUserData(_self->ob_itself, |
| data, |
| udType); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_RemoveUserData(UserDataObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| OSType udType; |
| long index; |
| #ifndef RemoveUserData |
| PyMac_PRECHECK(RemoveUserData); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| PyMac_GetOSType, &udType, |
| &index)) |
| return NULL; |
| _err = RemoveUserData(_self->ob_itself, |
| udType, |
| index); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_CountUserDataType(UserDataObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| OSType udType; |
| #ifndef CountUserDataType |
| PyMac_PRECHECK(CountUserDataType); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetOSType, &udType)) |
| return NULL; |
| _rv = CountUserDataType(_self->ob_itself, |
| udType); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_GetNextUserDataType(UserDataObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| OSType udType; |
| #ifndef GetNextUserDataType |
| PyMac_PRECHECK(GetNextUserDataType); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetOSType, &udType)) |
| return NULL; |
| _rv = GetNextUserDataType(_self->ob_itself, |
| udType); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_AddUserDataText(UserDataObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle data; |
| OSType udType; |
| long index; |
| short itlRegionTag; |
| #ifndef AddUserDataText |
| PyMac_PRECHECK(AddUserDataText); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&lh", |
| ResObj_Convert, &data, |
| PyMac_GetOSType, &udType, |
| &index, |
| &itlRegionTag)) |
| return NULL; |
| _err = AddUserDataText(_self->ob_itself, |
| data, |
| udType, |
| index, |
| itlRegionTag); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_GetUserDataText(UserDataObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle data; |
| OSType udType; |
| long index; |
| short itlRegionTag; |
| #ifndef GetUserDataText |
| PyMac_PRECHECK(GetUserDataText); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&lh", |
| ResObj_Convert, &data, |
| PyMac_GetOSType, &udType, |
| &index, |
| &itlRegionTag)) |
| return NULL; |
| _err = GetUserDataText(_self->ob_itself, |
| data, |
| udType, |
| index, |
| itlRegionTag); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_RemoveUserDataText(UserDataObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| OSType udType; |
| long index; |
| short itlRegionTag; |
| #ifndef RemoveUserDataText |
| PyMac_PRECHECK(RemoveUserDataText); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&lh", |
| PyMac_GetOSType, &udType, |
| &index, |
| &itlRegionTag)) |
| return NULL; |
| _err = RemoveUserDataText(_self->ob_itself, |
| udType, |
| index, |
| itlRegionTag); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_PutUserDataIntoHandle(UserDataObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle h; |
| #ifndef PutUserDataIntoHandle |
| PyMac_PRECHECK(PutUserDataIntoHandle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &h)) |
| return NULL; |
| _err = PutUserDataIntoHandle(_self->ob_itself, |
| h); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyMethodDef UserDataObj_methods[] = { |
| {"GetUserData", (PyCFunction)UserDataObj_GetUserData, 1, |
| PyDoc_STR("(Handle data, OSType udType, long index) -> None")}, |
| {"AddUserData", (PyCFunction)UserDataObj_AddUserData, 1, |
| PyDoc_STR("(Handle data, OSType udType) -> None")}, |
| {"RemoveUserData", (PyCFunction)UserDataObj_RemoveUserData, 1, |
| PyDoc_STR("(OSType udType, long index) -> None")}, |
| {"CountUserDataType", (PyCFunction)UserDataObj_CountUserDataType, 1, |
| PyDoc_STR("(OSType udType) -> (short _rv)")}, |
| {"GetNextUserDataType", (PyCFunction)UserDataObj_GetNextUserDataType, 1, |
| PyDoc_STR("(OSType udType) -> (long _rv)")}, |
| {"AddUserDataText", (PyCFunction)UserDataObj_AddUserDataText, 1, |
| PyDoc_STR("(Handle data, OSType udType, long index, short itlRegionTag) -> None")}, |
| {"GetUserDataText", (PyCFunction)UserDataObj_GetUserDataText, 1, |
| PyDoc_STR("(Handle data, OSType udType, long index, short itlRegionTag) -> None")}, |
| {"RemoveUserDataText", (PyCFunction)UserDataObj_RemoveUserDataText, 1, |
| PyDoc_STR("(OSType udType, long index, short itlRegionTag) -> None")}, |
| {"PutUserDataIntoHandle", (PyCFunction)UserDataObj_PutUserDataIntoHandle, 1, |
| PyDoc_STR("(Handle h) -> None")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define UserDataObj_getsetlist NULL |
| |
| |
| #define UserDataObj_compare NULL |
| |
| #define UserDataObj_repr NULL |
| |
| #define UserDataObj_hash NULL |
| #define UserDataObj_tp_init 0 |
| |
| #define UserDataObj_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *UserDataObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) |
| { |
| PyObject *self; |
| UserData itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, UserDataObj_Convert, &itself)) return NULL; |
| if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((UserDataObject *)self)->ob_itself = itself; |
| return self; |
| } |
| |
| #define UserDataObj_tp_free PyObject_Del |
| |
| |
| PyTypeObject UserData_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_Qt.UserData", /*tp_name*/ |
| sizeof(UserDataObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) UserDataObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*tp_setattr*/ |
| (cmpfunc) UserDataObj_compare, /*tp_compare*/ |
| (reprfunc) UserDataObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) UserDataObj_hash, /*tp_hash*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| UserDataObj_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| UserDataObj_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| UserDataObj_tp_init, /* tp_init */ |
| UserDataObj_tp_alloc, /* tp_alloc */ |
| UserDataObj_tp_new, /* tp_new */ |
| UserDataObj_tp_free, /* tp_free */ |
| }; |
| |
| /* -------------------- End object type UserData -------------------- */ |
| |
| |
| /* ----------------------- Object type Media ------------------------ */ |
| |
| PyTypeObject Media_Type; |
| |
| #define MediaObj_Check(x) ((x)->ob_type == &Media_Type || PyObject_TypeCheck((x), &Media_Type)) |
| |
| typedef struct MediaObject { |
| PyObject_HEAD |
| Media ob_itself; |
| } MediaObject; |
| |
| PyObject *MediaObj_New(Media itself) |
| { |
| MediaObject *it; |
| if (itself == NULL) { |
| PyErr_SetString(Qt_Error,"Cannot create null Media"); |
| return NULL; |
| } |
| it = PyObject_NEW(MediaObject, &Media_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| return (PyObject *)it; |
| } |
| int MediaObj_Convert(PyObject *v, Media *p_itself) |
| { |
| if (!MediaObj_Check(v)) |
| { |
| PyErr_SetString(PyExc_TypeError, "Media required"); |
| return 0; |
| } |
| *p_itself = ((MediaObject *)v)->ob_itself; |
| return 1; |
| } |
| |
| static void MediaObj_dealloc(MediaObject *self) |
| { |
| DisposeTrackMedia(self->ob_itself); |
| self->ob_type->tp_free((PyObject *)self); |
| } |
| |
| static PyObject *MediaObj_LoadMediaIntoRam(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue time; |
| TimeValue duration; |
| long flags; |
| #ifndef LoadMediaIntoRam |
| PyMac_PRECHECK(LoadMediaIntoRam); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lll", |
| &time, |
| &duration, |
| &flags)) |
| return NULL; |
| _err = LoadMediaIntoRam(_self->ob_itself, |
| time, |
| duration, |
| flags); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaTrack(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| #ifndef GetMediaTrack |
| PyMac_PRECHECK(GetMediaTrack); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaTrack(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaCreationTime(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| unsigned long _rv; |
| #ifndef GetMediaCreationTime |
| PyMac_PRECHECK(GetMediaCreationTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaCreationTime(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaModificationTime(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| unsigned long _rv; |
| #ifndef GetMediaModificationTime |
| PyMac_PRECHECK(GetMediaModificationTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaModificationTime(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaTimeScale(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeScale _rv; |
| #ifndef GetMediaTimeScale |
| PyMac_PRECHECK(GetMediaTimeScale); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaTimeScale(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaTimeScale(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeScale timeScale; |
| #ifndef SetMediaTimeScale |
| PyMac_PRECHECK(SetMediaTimeScale); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &timeScale)) |
| return NULL; |
| SetMediaTimeScale(_self->ob_itself, |
| timeScale); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaDuration(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| #ifndef GetMediaDuration |
| PyMac_PRECHECK(GetMediaDuration); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaDuration(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaLanguage(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| #ifndef GetMediaLanguage |
| PyMac_PRECHECK(GetMediaLanguage); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaLanguage(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaLanguage(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short language; |
| #ifndef SetMediaLanguage |
| PyMac_PRECHECK(SetMediaLanguage); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &language)) |
| return NULL; |
| SetMediaLanguage(_self->ob_itself, |
| language); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaQuality(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| #ifndef GetMediaQuality |
| PyMac_PRECHECK(GetMediaQuality); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaQuality(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaQuality(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short quality; |
| #ifndef SetMediaQuality |
| PyMac_PRECHECK(SetMediaQuality); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &quality)) |
| return NULL; |
| SetMediaQuality(_self->ob_itself, |
| quality); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaHandlerDescription(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSType mediaType; |
| Str255 creatorName; |
| OSType creatorManufacturer; |
| #ifndef GetMediaHandlerDescription |
| PyMac_PRECHECK(GetMediaHandlerDescription); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetStr255, creatorName)) |
| return NULL; |
| GetMediaHandlerDescription(_self->ob_itself, |
| &mediaType, |
| creatorName, |
| &creatorManufacturer); |
| _res = Py_BuildValue("O&O&", |
| PyMac_BuildOSType, mediaType, |
| PyMac_BuildOSType, creatorManufacturer); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaUserData(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| UserData _rv; |
| #ifndef GetMediaUserData |
| PyMac_PRECHECK(GetMediaUserData); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaUserData(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| UserDataObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaHandler(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| MediaHandler _rv; |
| #ifndef GetMediaHandler |
| PyMac_PRECHECK(GetMediaHandler); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaHandler(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| CmpInstObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaHandler(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| MediaHandlerComponent mH; |
| #ifndef SetMediaHandler |
| PyMac_PRECHECK(SetMediaHandler); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpObj_Convert, &mH)) |
| return NULL; |
| _err = SetMediaHandler(_self->ob_itself, |
| mH); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_BeginMediaEdits(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| #ifndef BeginMediaEdits |
| PyMac_PRECHECK(BeginMediaEdits); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = BeginMediaEdits(_self->ob_itself); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_EndMediaEdits(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| #ifndef EndMediaEdits |
| PyMac_PRECHECK(EndMediaEdits); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = EndMediaEdits(_self->ob_itself); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaDefaultDataRefIndex(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short index; |
| #ifndef SetMediaDefaultDataRefIndex |
| PyMac_PRECHECK(SetMediaDefaultDataRefIndex); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &index)) |
| return NULL; |
| _err = SetMediaDefaultDataRefIndex(_self->ob_itself, |
| index); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaDataHandlerDescription(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short index; |
| OSType dhType; |
| Str255 creatorName; |
| OSType creatorManufacturer; |
| #ifndef GetMediaDataHandlerDescription |
| PyMac_PRECHECK(GetMediaDataHandlerDescription); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hO&", |
| &index, |
| PyMac_GetStr255, creatorName)) |
| return NULL; |
| GetMediaDataHandlerDescription(_self->ob_itself, |
| index, |
| &dhType, |
| creatorName, |
| &creatorManufacturer); |
| _res = Py_BuildValue("O&O&", |
| PyMac_BuildOSType, dhType, |
| PyMac_BuildOSType, creatorManufacturer); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaDataHandler(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| DataHandler _rv; |
| short index; |
| #ifndef GetMediaDataHandler |
| PyMac_PRECHECK(GetMediaDataHandler); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &index)) |
| return NULL; |
| _rv = GetMediaDataHandler(_self->ob_itself, |
| index); |
| _res = Py_BuildValue("O&", |
| CmpInstObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaDataHandler(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short index; |
| DataHandlerComponent dataHandler; |
| #ifndef SetMediaDataHandler |
| PyMac_PRECHECK(SetMediaDataHandler); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hO&", |
| &index, |
| CmpObj_Convert, &dataHandler)) |
| return NULL; |
| _err = SetMediaDataHandler(_self->ob_itself, |
| index, |
| dataHandler); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaSampleDescriptionCount(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| #ifndef GetMediaSampleDescriptionCount |
| PyMac_PRECHECK(GetMediaSampleDescriptionCount); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaSampleDescriptionCount(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaSampleDescription(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long index; |
| SampleDescriptionHandle descH; |
| #ifndef GetMediaSampleDescription |
| PyMac_PRECHECK(GetMediaSampleDescription); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lO&", |
| &index, |
| ResObj_Convert, &descH)) |
| return NULL; |
| GetMediaSampleDescription(_self->ob_itself, |
| index, |
| descH); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaSampleDescription(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long index; |
| SampleDescriptionHandle descH; |
| #ifndef SetMediaSampleDescription |
| PyMac_PRECHECK(SetMediaSampleDescription); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lO&", |
| &index, |
| ResObj_Convert, &descH)) |
| return NULL; |
| _err = SetMediaSampleDescription(_self->ob_itself, |
| index, |
| descH); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaSampleCount(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| #ifndef GetMediaSampleCount |
| PyMac_PRECHECK(GetMediaSampleCount); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaSampleCount(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaSyncSampleCount(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| #ifndef GetMediaSyncSampleCount |
| PyMac_PRECHECK(GetMediaSyncSampleCount); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaSyncSampleCount(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SampleNumToMediaTime(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long logicalSampleNum; |
| TimeValue sampleTime; |
| TimeValue sampleDuration; |
| #ifndef SampleNumToMediaTime |
| PyMac_PRECHECK(SampleNumToMediaTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &logicalSampleNum)) |
| return NULL; |
| SampleNumToMediaTime(_self->ob_itself, |
| logicalSampleNum, |
| &sampleTime, |
| &sampleDuration); |
| _res = Py_BuildValue("ll", |
| sampleTime, |
| sampleDuration); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_MediaTimeToSampleNum(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue time; |
| long sampleNum; |
| TimeValue sampleTime; |
| TimeValue sampleDuration; |
| #ifndef MediaTimeToSampleNum |
| PyMac_PRECHECK(MediaTimeToSampleNum); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &time)) |
| return NULL; |
| MediaTimeToSampleNum(_self->ob_itself, |
| time, |
| &sampleNum, |
| &sampleTime, |
| &sampleDuration); |
| _res = Py_BuildValue("lll", |
| sampleNum, |
| sampleTime, |
| sampleDuration); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_AddMediaSample(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle dataIn; |
| long inOffset; |
| unsigned long size; |
| TimeValue durationPerSample; |
| SampleDescriptionHandle sampleDescriptionH; |
| long numberOfSamples; |
| short sampleFlags; |
| TimeValue sampleTime; |
| #ifndef AddMediaSample |
| PyMac_PRECHECK(AddMediaSample); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&lllO&lh", |
| ResObj_Convert, &dataIn, |
| &inOffset, |
| &size, |
| &durationPerSample, |
| ResObj_Convert, &sampleDescriptionH, |
| &numberOfSamples, |
| &sampleFlags)) |
| return NULL; |
| _err = AddMediaSample(_self->ob_itself, |
| dataIn, |
| inOffset, |
| size, |
| durationPerSample, |
| sampleDescriptionH, |
| numberOfSamples, |
| sampleFlags, |
| &sampleTime); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| sampleTime); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_AddMediaSampleReference(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long dataOffset; |
| unsigned long size; |
| TimeValue durationPerSample; |
| SampleDescriptionHandle sampleDescriptionH; |
| long numberOfSamples; |
| short sampleFlags; |
| TimeValue sampleTime; |
| #ifndef AddMediaSampleReference |
| PyMac_PRECHECK(AddMediaSampleReference); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lllO&lh", |
| &dataOffset, |
| &size, |
| &durationPerSample, |
| ResObj_Convert, &sampleDescriptionH, |
| &numberOfSamples, |
| &sampleFlags)) |
| return NULL; |
| _err = AddMediaSampleReference(_self->ob_itself, |
| dataOffset, |
| size, |
| durationPerSample, |
| sampleDescriptionH, |
| numberOfSamples, |
| sampleFlags, |
| &sampleTime); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| sampleTime); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaSample(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle dataOut; |
| long maxSizeToGrow; |
| long size; |
| TimeValue time; |
| TimeValue sampleTime; |
| TimeValue durationPerSample; |
| SampleDescriptionHandle sampleDescriptionH; |
| long sampleDescriptionIndex; |
| long maxNumberOfSamples; |
| long numberOfSamples; |
| short sampleFlags; |
| #ifndef GetMediaSample |
| PyMac_PRECHECK(GetMediaSample); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&llO&l", |
| ResObj_Convert, &dataOut, |
| &maxSizeToGrow, |
| &time, |
| ResObj_Convert, &sampleDescriptionH, |
| &maxNumberOfSamples)) |
| return NULL; |
| _err = GetMediaSample(_self->ob_itself, |
| dataOut, |
| maxSizeToGrow, |
| &size, |
| time, |
| &sampleTime, |
| &durationPerSample, |
| sampleDescriptionH, |
| &sampleDescriptionIndex, |
| maxNumberOfSamples, |
| &numberOfSamples, |
| &sampleFlags); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("lllllh", |
| size, |
| sampleTime, |
| durationPerSample, |
| sampleDescriptionIndex, |
| numberOfSamples, |
| sampleFlags); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaSampleReference(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long dataOffset; |
| long size; |
| TimeValue time; |
| TimeValue sampleTime; |
| TimeValue durationPerSample; |
| SampleDescriptionHandle sampleDescriptionH; |
| long sampleDescriptionIndex; |
| long maxNumberOfSamples; |
| long numberOfSamples; |
| short sampleFlags; |
| #ifndef GetMediaSampleReference |
| PyMac_PRECHECK(GetMediaSampleReference); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lO&l", |
| &time, |
| ResObj_Convert, &sampleDescriptionH, |
| &maxNumberOfSamples)) |
| return NULL; |
| _err = GetMediaSampleReference(_self->ob_itself, |
| &dataOffset, |
| &size, |
| time, |
| &sampleTime, |
| &durationPerSample, |
| sampleDescriptionH, |
| &sampleDescriptionIndex, |
| maxNumberOfSamples, |
| &numberOfSamples, |
| &sampleFlags); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("llllllh", |
| dataOffset, |
| size, |
| sampleTime, |
| durationPerSample, |
| sampleDescriptionIndex, |
| numberOfSamples, |
| sampleFlags); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaPreferredChunkSize(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long maxChunkSize; |
| #ifndef SetMediaPreferredChunkSize |
| PyMac_PRECHECK(SetMediaPreferredChunkSize); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &maxChunkSize)) |
| return NULL; |
| _err = SetMediaPreferredChunkSize(_self->ob_itself, |
| maxChunkSize); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaPreferredChunkSize(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long maxChunkSize; |
| #ifndef GetMediaPreferredChunkSize |
| PyMac_PRECHECK(GetMediaPreferredChunkSize); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetMediaPreferredChunkSize(_self->ob_itself, |
| &maxChunkSize); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| maxChunkSize); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaShadowSync(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long frameDiffSampleNum; |
| long syncSampleNum; |
| #ifndef SetMediaShadowSync |
| PyMac_PRECHECK(SetMediaShadowSync); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &frameDiffSampleNum, |
| &syncSampleNum)) |
| return NULL; |
| _err = SetMediaShadowSync(_self->ob_itself, |
| frameDiffSampleNum, |
| syncSampleNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaShadowSync(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long frameDiffSampleNum; |
| long syncSampleNum; |
| #ifndef GetMediaShadowSync |
| PyMac_PRECHECK(GetMediaShadowSync); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &frameDiffSampleNum)) |
| return NULL; |
| _err = GetMediaShadowSync(_self->ob_itself, |
| frameDiffSampleNum, |
| &syncSampleNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| syncSampleNum); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaDataSize(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| TimeValue startTime; |
| TimeValue duration; |
| #ifndef GetMediaDataSize |
| PyMac_PRECHECK(GetMediaDataSize); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| _rv = GetMediaDataSize(_self->ob_itself, |
| startTime, |
| duration); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaDataSize64(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue startTime; |
| TimeValue duration; |
| wide dataSize; |
| #ifndef GetMediaDataSize64 |
| PyMac_PRECHECK(GetMediaDataSize64); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| _err = GetMediaDataSize64(_self->ob_itself, |
| startTime, |
| duration, |
| &dataSize); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| PyMac_Buildwide, dataSize); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaNextInterestingTime(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short interestingTimeFlags; |
| TimeValue time; |
| Fixed rate; |
| TimeValue interestingTime; |
| TimeValue interestingDuration; |
| #ifndef GetMediaNextInterestingTime |
| PyMac_PRECHECK(GetMediaNextInterestingTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hlO&", |
| &interestingTimeFlags, |
| &time, |
| PyMac_GetFixed, &rate)) |
| return NULL; |
| GetMediaNextInterestingTime(_self->ob_itself, |
| interestingTimeFlags, |
| time, |
| rate, |
| &interestingTime, |
| &interestingDuration); |
| _res = Py_BuildValue("ll", |
| interestingTime, |
| interestingDuration); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaDataRef(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short index; |
| Handle dataRef; |
| OSType dataRefType; |
| long dataRefAttributes; |
| #ifndef GetMediaDataRef |
| PyMac_PRECHECK(GetMediaDataRef); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &index)) |
| return NULL; |
| _err = GetMediaDataRef(_self->ob_itself, |
| index, |
| &dataRef, |
| &dataRefType, |
| &dataRefAttributes); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&O&l", |
| ResObj_New, dataRef, |
| PyMac_BuildOSType, dataRefType, |
| dataRefAttributes); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaDataRef(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short index; |
| Handle dataRef; |
| OSType dataRefType; |
| #ifndef SetMediaDataRef |
| PyMac_PRECHECK(SetMediaDataRef); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hO&O&", |
| &index, |
| ResObj_Convert, &dataRef, |
| PyMac_GetOSType, &dataRefType)) |
| return NULL; |
| _err = SetMediaDataRef(_self->ob_itself, |
| index, |
| dataRef, |
| dataRefType); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaDataRefAttributes(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short index; |
| long dataRefAttributes; |
| #ifndef SetMediaDataRefAttributes |
| PyMac_PRECHECK(SetMediaDataRefAttributes); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hl", |
| &index, |
| &dataRefAttributes)) |
| return NULL; |
| _err = SetMediaDataRefAttributes(_self->ob_itself, |
| index, |
| dataRefAttributes); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_AddMediaDataRef(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short index; |
| Handle dataRef; |
| OSType dataRefType; |
| #ifndef AddMediaDataRef |
| PyMac_PRECHECK(AddMediaDataRef); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| ResObj_Convert, &dataRef, |
| PyMac_GetOSType, &dataRefType)) |
| return NULL; |
| _err = AddMediaDataRef(_self->ob_itself, |
| &index, |
| dataRef, |
| dataRefType); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| index); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaDataRefCount(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short count; |
| #ifndef GetMediaDataRefCount |
| PyMac_PRECHECK(GetMediaDataRefCount); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetMediaDataRefCount(_self->ob_itself, |
| &count); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| count); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaPlayHints(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long flags; |
| long flagsMask; |
| #ifndef SetMediaPlayHints |
| PyMac_PRECHECK(SetMediaPlayHints); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &flags, |
| &flagsMask)) |
| return NULL; |
| SetMediaPlayHints(_self->ob_itself, |
| flags, |
| flagsMask); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaPlayHints(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long flags; |
| #ifndef GetMediaPlayHints |
| PyMac_PRECHECK(GetMediaPlayHints); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetMediaPlayHints(_self->ob_itself, |
| &flags); |
| _res = Py_BuildValue("l", |
| flags); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaNextInterestingTimeOnly(MediaObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short interestingTimeFlags; |
| TimeValue time; |
| Fixed rate; |
| TimeValue interestingTime; |
| #ifndef GetMediaNextInterestingTimeOnly |
| PyMac_PRECHECK(GetMediaNextInterestingTimeOnly); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hlO&", |
| &interestingTimeFlags, |
| &time, |
| PyMac_GetFixed, &rate)) |
| return NULL; |
| GetMediaNextInterestingTimeOnly(_self->ob_itself, |
| interestingTimeFlags, |
| time, |
| rate, |
| &interestingTime); |
| _res = Py_BuildValue("l", |
| interestingTime); |
| return _res; |
| } |
| |
| static PyMethodDef MediaObj_methods[] = { |
| {"LoadMediaIntoRam", (PyCFunction)MediaObj_LoadMediaIntoRam, 1, |
| PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")}, |
| {"GetMediaTrack", (PyCFunction)MediaObj_GetMediaTrack, 1, |
| PyDoc_STR("() -> (Track _rv)")}, |
| {"GetMediaCreationTime", (PyCFunction)MediaObj_GetMediaCreationTime, 1, |
| PyDoc_STR("() -> (unsigned long _rv)")}, |
| {"GetMediaModificationTime", (PyCFunction)MediaObj_GetMediaModificationTime, 1, |
| PyDoc_STR("() -> (unsigned long _rv)")}, |
| {"GetMediaTimeScale", (PyCFunction)MediaObj_GetMediaTimeScale, 1, |
| PyDoc_STR("() -> (TimeScale _rv)")}, |
| {"SetMediaTimeScale", (PyCFunction)MediaObj_SetMediaTimeScale, 1, |
| PyDoc_STR("(TimeScale timeScale) -> None")}, |
| {"GetMediaDuration", (PyCFunction)MediaObj_GetMediaDuration, 1, |
| PyDoc_STR("() -> (TimeValue _rv)")}, |
| {"GetMediaLanguage", (PyCFunction)MediaObj_GetMediaLanguage, 1, |
| PyDoc_STR("() -> (short _rv)")}, |
| {"SetMediaLanguage", (PyCFunction)MediaObj_SetMediaLanguage, 1, |
| PyDoc_STR("(short language) -> None")}, |
| {"GetMediaQuality", (PyCFunction)MediaObj_GetMediaQuality, 1, |
| PyDoc_STR("() -> (short _rv)")}, |
| {"SetMediaQuality", (PyCFunction)MediaObj_SetMediaQuality, 1, |
| PyDoc_STR("(short quality) -> None")}, |
| {"GetMediaHandlerDescription", (PyCFunction)MediaObj_GetMediaHandlerDescription, 1, |
| PyDoc_STR("(Str255 creatorName) -> (OSType mediaType, OSType creatorManufacturer)")}, |
| {"GetMediaUserData", (PyCFunction)MediaObj_GetMediaUserData, 1, |
| PyDoc_STR("() -> (UserData _rv)")}, |
| {"GetMediaHandler", (PyCFunction)MediaObj_GetMediaHandler, 1, |
| PyDoc_STR("() -> (MediaHandler _rv)")}, |
| {"SetMediaHandler", (PyCFunction)MediaObj_SetMediaHandler, 1, |
| PyDoc_STR("(MediaHandlerComponent mH) -> None")}, |
| {"BeginMediaEdits", (PyCFunction)MediaObj_BeginMediaEdits, 1, |
| PyDoc_STR("() -> None")}, |
| {"EndMediaEdits", (PyCFunction)MediaObj_EndMediaEdits, 1, |
| PyDoc_STR("() -> None")}, |
| {"SetMediaDefaultDataRefIndex", (PyCFunction)MediaObj_SetMediaDefaultDataRefIndex, 1, |
| PyDoc_STR("(short index) -> None")}, |
| {"GetMediaDataHandlerDescription", (PyCFunction)MediaObj_GetMediaDataHandlerDescription, 1, |
| PyDoc_STR("(short index, Str255 creatorName) -> (OSType dhType, OSType creatorManufacturer)")}, |
| {"GetMediaDataHandler", (PyCFunction)MediaObj_GetMediaDataHandler, 1, |
| PyDoc_STR("(short index) -> (DataHandler _rv)")}, |
| {"SetMediaDataHandler", (PyCFunction)MediaObj_SetMediaDataHandler, 1, |
| PyDoc_STR("(short index, DataHandlerComponent dataHandler) -> None")}, |
| {"GetMediaSampleDescriptionCount", (PyCFunction)MediaObj_GetMediaSampleDescriptionCount, 1, |
| PyDoc_STR("() -> (long _rv)")}, |
| {"GetMediaSampleDescription", (PyCFunction)MediaObj_GetMediaSampleDescription, 1, |
| PyDoc_STR("(long index, SampleDescriptionHandle descH) -> None")}, |
| {"SetMediaSampleDescription", (PyCFunction)MediaObj_SetMediaSampleDescription, 1, |
| PyDoc_STR("(long index, SampleDescriptionHandle descH) -> None")}, |
| {"GetMediaSampleCount", (PyCFunction)MediaObj_GetMediaSampleCount, 1, |
| PyDoc_STR("() -> (long _rv)")}, |
| {"GetMediaSyncSampleCount", (PyCFunction)MediaObj_GetMediaSyncSampleCount, 1, |
| PyDoc_STR("() -> (long _rv)")}, |
| {"SampleNumToMediaTime", (PyCFunction)MediaObj_SampleNumToMediaTime, 1, |
| PyDoc_STR("(long logicalSampleNum) -> (TimeValue sampleTime, TimeValue sampleDuration)")}, |
| {"MediaTimeToSampleNum", (PyCFunction)MediaObj_MediaTimeToSampleNum, 1, |
| PyDoc_STR("(TimeValue time) -> (long sampleNum, TimeValue sampleTime, TimeValue sampleDuration)")}, |
| {"AddMediaSample", (PyCFunction)MediaObj_AddMediaSample, 1, |
| PyDoc_STR("(Handle dataIn, long inOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)")}, |
| {"AddMediaSampleReference", (PyCFunction)MediaObj_AddMediaSampleReference, 1, |
| PyDoc_STR("(long dataOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)")}, |
| {"GetMediaSample", (PyCFunction)MediaObj_GetMediaSample, 1, |
| PyDoc_STR("(Handle dataOut, long maxSizeToGrow, TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)")}, |
| {"GetMediaSampleReference", (PyCFunction)MediaObj_GetMediaSampleReference, 1, |
| PyDoc_STR("(TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long dataOffset, long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)")}, |
| {"SetMediaPreferredChunkSize", (PyCFunction)MediaObj_SetMediaPreferredChunkSize, 1, |
| PyDoc_STR("(long maxChunkSize) -> None")}, |
| {"GetMediaPreferredChunkSize", (PyCFunction)MediaObj_GetMediaPreferredChunkSize, 1, |
| PyDoc_STR("() -> (long maxChunkSize)")}, |
| {"SetMediaShadowSync", (PyCFunction)MediaObj_SetMediaShadowSync, 1, |
| PyDoc_STR("(long frameDiffSampleNum, long syncSampleNum) -> None")}, |
| {"GetMediaShadowSync", (PyCFunction)MediaObj_GetMediaShadowSync, 1, |
| PyDoc_STR("(long frameDiffSampleNum) -> (long syncSampleNum)")}, |
| {"GetMediaDataSize", (PyCFunction)MediaObj_GetMediaDataSize, 1, |
| PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")}, |
| {"GetMediaDataSize64", (PyCFunction)MediaObj_GetMediaDataSize64, 1, |
| PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")}, |
| {"GetMediaNextInterestingTime", (PyCFunction)MediaObj_GetMediaNextInterestingTime, 1, |
| PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")}, |
| {"GetMediaDataRef", (PyCFunction)MediaObj_GetMediaDataRef, 1, |
| PyDoc_STR("(short index) -> (Handle dataRef, OSType dataRefType, long dataRefAttributes)")}, |
| {"SetMediaDataRef", (PyCFunction)MediaObj_SetMediaDataRef, 1, |
| PyDoc_STR("(short index, Handle dataRef, OSType dataRefType) -> None")}, |
| {"SetMediaDataRefAttributes", (PyCFunction)MediaObj_SetMediaDataRefAttributes, 1, |
| PyDoc_STR("(short index, long dataRefAttributes) -> None")}, |
| {"AddMediaDataRef", (PyCFunction)MediaObj_AddMediaDataRef, 1, |
| PyDoc_STR("(Handle dataRef, OSType dataRefType) -> (short index)")}, |
| {"GetMediaDataRefCount", (PyCFunction)MediaObj_GetMediaDataRefCount, 1, |
| PyDoc_STR("() -> (short count)")}, |
| {"SetMediaPlayHints", (PyCFunction)MediaObj_SetMediaPlayHints, 1, |
| PyDoc_STR("(long flags, long flagsMask) -> None")}, |
| {"GetMediaPlayHints", (PyCFunction)MediaObj_GetMediaPlayHints, 1, |
| PyDoc_STR("() -> (long flags)")}, |
| {"GetMediaNextInterestingTimeOnly", (PyCFunction)MediaObj_GetMediaNextInterestingTimeOnly, 1, |
| PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime)")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define MediaObj_getsetlist NULL |
| |
| |
| #define MediaObj_compare NULL |
| |
| #define MediaObj_repr NULL |
| |
| #define MediaObj_hash NULL |
| #define MediaObj_tp_init 0 |
| |
| #define MediaObj_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *MediaObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) |
| { |
| PyObject *self; |
| Media itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, MediaObj_Convert, &itself)) return NULL; |
| if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((MediaObject *)self)->ob_itself = itself; |
| return self; |
| } |
| |
| #define MediaObj_tp_free PyObject_Del |
| |
| |
| PyTypeObject Media_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_Qt.Media", /*tp_name*/ |
| sizeof(MediaObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) MediaObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*tp_setattr*/ |
| (cmpfunc) MediaObj_compare, /*tp_compare*/ |
| (reprfunc) MediaObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) MediaObj_hash, /*tp_hash*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| MediaObj_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| MediaObj_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| MediaObj_tp_init, /* tp_init */ |
| MediaObj_tp_alloc, /* tp_alloc */ |
| MediaObj_tp_new, /* tp_new */ |
| MediaObj_tp_free, /* tp_free */ |
| }; |
| |
| /* --------------------- End object type Media ---------------------- */ |
| |
| |
| /* ----------------------- Object type Track ------------------------ */ |
| |
| PyTypeObject Track_Type; |
| |
| #define TrackObj_Check(x) ((x)->ob_type == &Track_Type || PyObject_TypeCheck((x), &Track_Type)) |
| |
| typedef struct TrackObject { |
| PyObject_HEAD |
| Track ob_itself; |
| } TrackObject; |
| |
| PyObject *TrackObj_New(Track itself) |
| { |
| TrackObject *it; |
| if (itself == NULL) { |
| PyErr_SetString(Qt_Error,"Cannot create null Track"); |
| return NULL; |
| } |
| it = PyObject_NEW(TrackObject, &Track_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| return (PyObject *)it; |
| } |
| int TrackObj_Convert(PyObject *v, Track *p_itself) |
| { |
| if (!TrackObj_Check(v)) |
| { |
| PyErr_SetString(PyExc_TypeError, "Track required"); |
| return 0; |
| } |
| *p_itself = ((TrackObject *)v)->ob_itself; |
| return 1; |
| } |
| |
| static void TrackObj_dealloc(TrackObject *self) |
| { |
| DisposeMovieTrack(self->ob_itself); |
| self->ob_type->tp_free((PyObject *)self); |
| } |
| |
| static PyObject *TrackObj_LoadTrackIntoRam(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue time; |
| TimeValue duration; |
| long flags; |
| #ifndef LoadTrackIntoRam |
| PyMac_PRECHECK(LoadTrackIntoRam); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lll", |
| &time, |
| &duration, |
| &flags)) |
| return NULL; |
| _err = LoadTrackIntoRam(_self->ob_itself, |
| time, |
| duration, |
| flags); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackPict(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| PicHandle _rv; |
| TimeValue time; |
| #ifndef GetTrackPict |
| PyMac_PRECHECK(GetTrackPict); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &time)) |
| return NULL; |
| _rv = GetTrackPict(_self->ob_itself, |
| time); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackClipRgn(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| #ifndef GetTrackClipRgn |
| PyMac_PRECHECK(GetTrackClipRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackClipRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackClipRgn(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle theClip; |
| #ifndef SetTrackClipRgn |
| PyMac_PRECHECK(SetTrackClipRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &theClip)) |
| return NULL; |
| SetTrackClipRgn(_self->ob_itself, |
| theClip); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackDisplayBoundsRgn(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| #ifndef GetTrackDisplayBoundsRgn |
| PyMac_PRECHECK(GetTrackDisplayBoundsRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackDisplayBoundsRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackMovieBoundsRgn(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| #ifndef GetTrackMovieBoundsRgn |
| PyMac_PRECHECK(GetTrackMovieBoundsRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackMovieBoundsRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackBoundsRgn(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| #ifndef GetTrackBoundsRgn |
| PyMac_PRECHECK(GetTrackBoundsRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackBoundsRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackMatte(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| PixMapHandle _rv; |
| #ifndef GetTrackMatte |
| PyMac_PRECHECK(GetTrackMatte); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackMatte(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackMatte(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| PixMapHandle theMatte; |
| #ifndef SetTrackMatte |
| PyMac_PRECHECK(SetTrackMatte); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &theMatte)) |
| return NULL; |
| SetTrackMatte(_self->ob_itself, |
| theMatte); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackID(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| #ifndef GetTrackID |
| PyMac_PRECHECK(GetTrackID); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackID(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackMovie(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| #ifndef GetTrackMovie |
| PyMac_PRECHECK(GetTrackMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackMovie(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackCreationTime(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| unsigned long _rv; |
| #ifndef GetTrackCreationTime |
| PyMac_PRECHECK(GetTrackCreationTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackCreationTime(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackModificationTime(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| unsigned long _rv; |
| #ifndef GetTrackModificationTime |
| PyMac_PRECHECK(GetTrackModificationTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackModificationTime(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackEnabled(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| #ifndef GetTrackEnabled |
| PyMac_PRECHECK(GetTrackEnabled); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackEnabled(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackEnabled(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean isEnabled; |
| #ifndef SetTrackEnabled |
| PyMac_PRECHECK(SetTrackEnabled); |
| #endif |
| if (!PyArg_ParseTuple(_args, "b", |
| &isEnabled)) |
| return NULL; |
| SetTrackEnabled(_self->ob_itself, |
| isEnabled); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackUsage(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| #ifndef GetTrackUsage |
| PyMac_PRECHECK(GetTrackUsage); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackUsage(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackUsage(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long usage; |
| #ifndef SetTrackUsage |
| PyMac_PRECHECK(SetTrackUsage); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &usage)) |
| return NULL; |
| SetTrackUsage(_self->ob_itself, |
| usage); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackDuration(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| #ifndef GetTrackDuration |
| PyMac_PRECHECK(GetTrackDuration); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackDuration(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackOffset(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| #ifndef GetTrackOffset |
| PyMac_PRECHECK(GetTrackOffset); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackOffset(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackOffset(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue movieOffsetTime; |
| #ifndef SetTrackOffset |
| PyMac_PRECHECK(SetTrackOffset); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &movieOffsetTime)) |
| return NULL; |
| SetTrackOffset(_self->ob_itself, |
| movieOffsetTime); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackLayer(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| #ifndef GetTrackLayer |
| PyMac_PRECHECK(GetTrackLayer); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackLayer(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackLayer(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short layer; |
| #ifndef SetTrackLayer |
| PyMac_PRECHECK(SetTrackLayer); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &layer)) |
| return NULL; |
| SetTrackLayer(_self->ob_itself, |
| layer); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackAlternate(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| #ifndef GetTrackAlternate |
| PyMac_PRECHECK(GetTrackAlternate); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackAlternate(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackAlternate(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Track alternateT; |
| #ifndef SetTrackAlternate |
| PyMac_PRECHECK(SetTrackAlternate); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| TrackObj_Convert, &alternateT)) |
| return NULL; |
| SetTrackAlternate(_self->ob_itself, |
| alternateT); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackVolume(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| #ifndef GetTrackVolume |
| PyMac_PRECHECK(GetTrackVolume); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackVolume(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackVolume(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short volume; |
| #ifndef SetTrackVolume |
| PyMac_PRECHECK(SetTrackVolume); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &volume)) |
| return NULL; |
| SetTrackVolume(_self->ob_itself, |
| volume); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackDimensions(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Fixed width; |
| Fixed height; |
| #ifndef GetTrackDimensions |
| PyMac_PRECHECK(GetTrackDimensions); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetTrackDimensions(_self->ob_itself, |
| &width, |
| &height); |
| _res = Py_BuildValue("O&O&", |
| PyMac_BuildFixed, width, |
| PyMac_BuildFixed, height); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackDimensions(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Fixed width; |
| Fixed height; |
| #ifndef SetTrackDimensions |
| PyMac_PRECHECK(SetTrackDimensions); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| PyMac_GetFixed, &width, |
| PyMac_GetFixed, &height)) |
| return NULL; |
| SetTrackDimensions(_self->ob_itself, |
| width, |
| height); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackUserData(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| UserData _rv; |
| #ifndef GetTrackUserData |
| PyMac_PRECHECK(GetTrackUserData); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackUserData(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| UserDataObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackSoundLocalizationSettings(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle settings; |
| #ifndef GetTrackSoundLocalizationSettings |
| PyMac_PRECHECK(GetTrackSoundLocalizationSettings); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetTrackSoundLocalizationSettings(_self->ob_itself, |
| &settings); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| ResObj_New, settings); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackSoundLocalizationSettings(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle settings; |
| #ifndef SetTrackSoundLocalizationSettings |
| PyMac_PRECHECK(SetTrackSoundLocalizationSettings); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &settings)) |
| return NULL; |
| _err = SetTrackSoundLocalizationSettings(_self->ob_itself, |
| settings); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_NewTrackMedia(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Media _rv; |
| OSType mediaType; |
| TimeScale timeScale; |
| Handle dataRef; |
| OSType dataRefType; |
| #ifndef NewTrackMedia |
| PyMac_PRECHECK(NewTrackMedia); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&lO&O&", |
| PyMac_GetOSType, &mediaType, |
| &timeScale, |
| ResObj_Convert, &dataRef, |
| PyMac_GetOSType, &dataRefType)) |
| return NULL; |
| _rv = NewTrackMedia(_self->ob_itself, |
| mediaType, |
| timeScale, |
| dataRef, |
| dataRefType); |
| _res = Py_BuildValue("O&", |
| MediaObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackMedia(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Media _rv; |
| #ifndef GetTrackMedia |
| PyMac_PRECHECK(GetTrackMedia); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackMedia(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| MediaObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_InsertMediaIntoTrack(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue trackStart; |
| TimeValue mediaTime; |
| TimeValue mediaDuration; |
| Fixed mediaRate; |
| #ifndef InsertMediaIntoTrack |
| PyMac_PRECHECK(InsertMediaIntoTrack); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lllO&", |
| &trackStart, |
| &mediaTime, |
| &mediaDuration, |
| PyMac_GetFixed, &mediaRate)) |
| return NULL; |
| _err = InsertMediaIntoTrack(_self->ob_itself, |
| trackStart, |
| mediaTime, |
| mediaDuration, |
| mediaRate); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_InsertTrackSegment(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Track dstTrack; |
| TimeValue srcIn; |
| TimeValue srcDuration; |
| TimeValue dstIn; |
| #ifndef InsertTrackSegment |
| PyMac_PRECHECK(InsertTrackSegment); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&lll", |
| TrackObj_Convert, &dstTrack, |
| &srcIn, |
| &srcDuration, |
| &dstIn)) |
| return NULL; |
| _err = InsertTrackSegment(_self->ob_itself, |
| dstTrack, |
| srcIn, |
| srcDuration, |
| dstIn); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_InsertEmptyTrackSegment(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue dstIn; |
| TimeValue dstDuration; |
| #ifndef InsertEmptyTrackSegment |
| PyMac_PRECHECK(InsertEmptyTrackSegment); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &dstIn, |
| &dstDuration)) |
| return NULL; |
| _err = InsertEmptyTrackSegment(_self->ob_itself, |
| dstIn, |
| dstDuration); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_DeleteTrackSegment(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue startTime; |
| TimeValue duration; |
| #ifndef DeleteTrackSegment |
| PyMac_PRECHECK(DeleteTrackSegment); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| _err = DeleteTrackSegment(_self->ob_itself, |
| startTime, |
| duration); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_ScaleTrackSegment(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue startTime; |
| TimeValue oldDuration; |
| TimeValue newDuration; |
| #ifndef ScaleTrackSegment |
| PyMac_PRECHECK(ScaleTrackSegment); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lll", |
| &startTime, |
| &oldDuration, |
| &newDuration)) |
| return NULL; |
| _err = ScaleTrackSegment(_self->ob_itself, |
| startTime, |
| oldDuration, |
| newDuration); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_IsScrapMovie(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Component _rv; |
| #ifndef IsScrapMovie |
| PyMac_PRECHECK(IsScrapMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = IsScrapMovie(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| CmpObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_CopyTrackSettings(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Track dstTrack; |
| #ifndef CopyTrackSettings |
| PyMac_PRECHECK(CopyTrackSettings); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| TrackObj_Convert, &dstTrack)) |
| return NULL; |
| _err = CopyTrackSettings(_self->ob_itself, |
| dstTrack); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_AddEmptyTrackToMovie(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie dstMovie; |
| Handle dataRef; |
| OSType dataRefType; |
| Track dstTrack; |
| #ifndef AddEmptyTrackToMovie |
| PyMac_PRECHECK(AddEmptyTrackToMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&", |
| MovieObj_Convert, &dstMovie, |
| ResObj_Convert, &dataRef, |
| PyMac_GetOSType, &dataRefType)) |
| return NULL; |
| _err = AddEmptyTrackToMovie(_self->ob_itself, |
| dstMovie, |
| dataRef, |
| dataRefType, |
| &dstTrack); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, dstTrack); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_AddClonedTrackToMovie(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie dstMovie; |
| long flags; |
| Track dstTrack; |
| #ifndef AddClonedTrackToMovie |
| PyMac_PRECHECK(AddClonedTrackToMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| MovieObj_Convert, &dstMovie, |
| &flags)) |
| return NULL; |
| _err = AddClonedTrackToMovie(_self->ob_itself, |
| dstMovie, |
| flags, |
| &dstTrack); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, dstTrack); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_AddTrackReference(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Track refTrack; |
| OSType refType; |
| long addedIndex; |
| #ifndef AddTrackReference |
| PyMac_PRECHECK(AddTrackReference); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| TrackObj_Convert, &refTrack, |
| PyMac_GetOSType, &refType)) |
| return NULL; |
| _err = AddTrackReference(_self->ob_itself, |
| refTrack, |
| refType, |
| &addedIndex); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| addedIndex); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_DeleteTrackReference(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| OSType refType; |
| long index; |
| #ifndef DeleteTrackReference |
| PyMac_PRECHECK(DeleteTrackReference); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| PyMac_GetOSType, &refType, |
| &index)) |
| return NULL; |
| _err = DeleteTrackReference(_self->ob_itself, |
| refType, |
| index); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackReference(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Track refTrack; |
| OSType refType; |
| long index; |
| #ifndef SetTrackReference |
| PyMac_PRECHECK(SetTrackReference); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&l", |
| TrackObj_Convert, &refTrack, |
| PyMac_GetOSType, &refType, |
| &index)) |
| return NULL; |
| _err = SetTrackReference(_self->ob_itself, |
| refTrack, |
| refType, |
| index); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackReference(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| OSType refType; |
| long index; |
| #ifndef GetTrackReference |
| PyMac_PRECHECK(GetTrackReference); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| PyMac_GetOSType, &refType, |
| &index)) |
| return NULL; |
| _rv = GetTrackReference(_self->ob_itself, |
| refType, |
| index); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetNextTrackReferenceType(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSType _rv; |
| OSType refType; |
| #ifndef GetNextTrackReferenceType |
| PyMac_PRECHECK(GetNextTrackReferenceType); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetOSType, &refType)) |
| return NULL; |
| _rv = GetNextTrackReferenceType(_self->ob_itself, |
| refType); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildOSType, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackReferenceCount(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| OSType refType; |
| #ifndef GetTrackReferenceCount |
| PyMac_PRECHECK(GetTrackReferenceCount); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetOSType, &refType)) |
| return NULL; |
| _rv = GetTrackReferenceCount(_self->ob_itself, |
| refType); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackEditRate(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Fixed _rv; |
| TimeValue atTime; |
| #ifndef GetTrackEditRate |
| PyMac_PRECHECK(GetTrackEditRate); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &atTime)) |
| return NULL; |
| _rv = GetTrackEditRate(_self->ob_itself, |
| atTime); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildFixed, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackDataSize(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| TimeValue startTime; |
| TimeValue duration; |
| #ifndef GetTrackDataSize |
| PyMac_PRECHECK(GetTrackDataSize); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| _rv = GetTrackDataSize(_self->ob_itself, |
| startTime, |
| duration); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackDataSize64(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue startTime; |
| TimeValue duration; |
| wide dataSize; |
| #ifndef GetTrackDataSize64 |
| PyMac_PRECHECK(GetTrackDataSize64); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| _err = GetTrackDataSize64(_self->ob_itself, |
| startTime, |
| duration, |
| &dataSize); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| PyMac_Buildwide, dataSize); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_PtInTrack(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| Point pt; |
| #ifndef PtInTrack |
| PyMac_PRECHECK(PtInTrack); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetPoint, &pt)) |
| return NULL; |
| _rv = PtInTrack(_self->ob_itself, |
| pt); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackNextInterestingTime(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short interestingTimeFlags; |
| TimeValue time; |
| Fixed rate; |
| TimeValue interestingTime; |
| TimeValue interestingDuration; |
| #ifndef GetTrackNextInterestingTime |
| PyMac_PRECHECK(GetTrackNextInterestingTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hlO&", |
| &interestingTimeFlags, |
| &time, |
| PyMac_GetFixed, &rate)) |
| return NULL; |
| GetTrackNextInterestingTime(_self->ob_itself, |
| interestingTimeFlags, |
| time, |
| rate, |
| &interestingTime, |
| &interestingDuration); |
| _res = Py_BuildValue("ll", |
| interestingTime, |
| interestingDuration); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackSegmentDisplayBoundsRgn(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| TimeValue time; |
| TimeValue duration; |
| #ifndef GetTrackSegmentDisplayBoundsRgn |
| PyMac_PRECHECK(GetTrackSegmentDisplayBoundsRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &time, |
| &duration)) |
| return NULL; |
| _rv = GetTrackSegmentDisplayBoundsRgn(_self->ob_itself, |
| time, |
| duration); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackStatus(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| #ifndef GetTrackStatus |
| PyMac_PRECHECK(GetTrackStatus); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackStatus(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackLoadSettings(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue preloadTime; |
| TimeValue preloadDuration; |
| long preloadFlags; |
| long defaultHints; |
| #ifndef SetTrackLoadSettings |
| PyMac_PRECHECK(SetTrackLoadSettings); |
| #endif |
| if (!PyArg_ParseTuple(_args, "llll", |
| &preloadTime, |
| &preloadDuration, |
| &preloadFlags, |
| &defaultHints)) |
| return NULL; |
| SetTrackLoadSettings(_self->ob_itself, |
| preloadTime, |
| preloadDuration, |
| preloadFlags, |
| defaultHints); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackLoadSettings(TrackObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue preloadTime; |
| TimeValue preloadDuration; |
| long preloadFlags; |
| long defaultHints; |
| #ifndef GetTrackLoadSettings |
| PyMac_PRECHECK(GetTrackLoadSettings); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetTrackLoadSettings(_self->ob_itself, |
| &preloadTime, |
| &preloadDuration, |
| &preloadFlags, |
| &defaultHints); |
| _res = Py_BuildValue("llll", |
| preloadTime, |
| preloadDuration, |
| preloadFlags, |
| defaultHints); |
| return _res; |
| } |
| |
| static PyMethodDef TrackObj_methods[] = { |
| {"LoadTrackIntoRam", (PyCFunction)TrackObj_LoadTrackIntoRam, 1, |
| PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")}, |
| {"GetTrackPict", (PyCFunction)TrackObj_GetTrackPict, 1, |
| PyDoc_STR("(TimeValue time) -> (PicHandle _rv)")}, |
| {"GetTrackClipRgn", (PyCFunction)TrackObj_GetTrackClipRgn, 1, |
| PyDoc_STR("() -> (RgnHandle _rv)")}, |
| {"SetTrackClipRgn", (PyCFunction)TrackObj_SetTrackClipRgn, 1, |
| PyDoc_STR("(RgnHandle theClip) -> None")}, |
| {"GetTrackDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackDisplayBoundsRgn, 1, |
| PyDoc_STR("() -> (RgnHandle _rv)")}, |
| {"GetTrackMovieBoundsRgn", (PyCFunction)TrackObj_GetTrackMovieBoundsRgn, 1, |
| PyDoc_STR("() -> (RgnHandle _rv)")}, |
| {"GetTrackBoundsRgn", (PyCFunction)TrackObj_GetTrackBoundsRgn, 1, |
| PyDoc_STR("() -> (RgnHandle _rv)")}, |
| {"GetTrackMatte", (PyCFunction)TrackObj_GetTrackMatte, 1, |
| PyDoc_STR("() -> (PixMapHandle _rv)")}, |
| {"SetTrackMatte", (PyCFunction)TrackObj_SetTrackMatte, 1, |
| PyDoc_STR("(PixMapHandle theMatte) -> None")}, |
| {"GetTrackID", (PyCFunction)TrackObj_GetTrackID, 1, |
| PyDoc_STR("() -> (long _rv)")}, |
| {"GetTrackMovie", (PyCFunction)TrackObj_GetTrackMovie, 1, |
| PyDoc_STR("() -> (Movie _rv)")}, |
| {"GetTrackCreationTime", (PyCFunction)TrackObj_GetTrackCreationTime, 1, |
| PyDoc_STR("() -> (unsigned long _rv)")}, |
| {"GetTrackModificationTime", (PyCFunction)TrackObj_GetTrackModificationTime, 1, |
| PyDoc_STR("() -> (unsigned long _rv)")}, |
| {"GetTrackEnabled", (PyCFunction)TrackObj_GetTrackEnabled, 1, |
| PyDoc_STR("() -> (Boolean _rv)")}, |
| {"SetTrackEnabled", (PyCFunction)TrackObj_SetTrackEnabled, 1, |
| PyDoc_STR("(Boolean isEnabled) -> None")}, |
| {"GetTrackUsage", (PyCFunction)TrackObj_GetTrackUsage, 1, |
| PyDoc_STR("() -> (long _rv)")}, |
| {"SetTrackUsage", (PyCFunction)TrackObj_SetTrackUsage, 1, |
| PyDoc_STR("(long usage) -> None")}, |
| {"GetTrackDuration", (PyCFunction)TrackObj_GetTrackDuration, 1, |
| PyDoc_STR("() -> (TimeValue _rv)")}, |
| {"GetTrackOffset", (PyCFunction)TrackObj_GetTrackOffset, 1, |
| PyDoc_STR("() -> (TimeValue _rv)")}, |
| {"SetTrackOffset", (PyCFunction)TrackObj_SetTrackOffset, 1, |
| PyDoc_STR("(TimeValue movieOffsetTime) -> None")}, |
| {"GetTrackLayer", (PyCFunction)TrackObj_GetTrackLayer, 1, |
| PyDoc_STR("() -> (short _rv)")}, |
| {"SetTrackLayer", (PyCFunction)TrackObj_SetTrackLayer, 1, |
| PyDoc_STR("(short layer) -> None")}, |
| {"GetTrackAlternate", (PyCFunction)TrackObj_GetTrackAlternate, 1, |
| PyDoc_STR("() -> (Track _rv)")}, |
| {"SetTrackAlternate", (PyCFunction)TrackObj_SetTrackAlternate, 1, |
| PyDoc_STR("(Track alternateT) -> None")}, |
| {"GetTrackVolume", (PyCFunction)TrackObj_GetTrackVolume, 1, |
| PyDoc_STR("() -> (short _rv)")}, |
| {"SetTrackVolume", (PyCFunction)TrackObj_SetTrackVolume, 1, |
| PyDoc_STR("(short volume) -> None")}, |
| {"GetTrackDimensions", (PyCFunction)TrackObj_GetTrackDimensions, 1, |
| PyDoc_STR("() -> (Fixed width, Fixed height)")}, |
| {"SetTrackDimensions", (PyCFunction)TrackObj_SetTrackDimensions, 1, |
| PyDoc_STR("(Fixed width, Fixed height) -> None")}, |
| {"GetTrackUserData", (PyCFunction)TrackObj_GetTrackUserData, 1, |
| PyDoc_STR("() -> (UserData _rv)")}, |
| {"GetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_GetTrackSoundLocalizationSettings, 1, |
| PyDoc_STR("() -> (Handle settings)")}, |
| {"SetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_SetTrackSoundLocalizationSettings, 1, |
| PyDoc_STR("(Handle settings) -> None")}, |
| {"NewTrackMedia", (PyCFunction)TrackObj_NewTrackMedia, 1, |
| PyDoc_STR("(OSType mediaType, TimeScale timeScale, Handle dataRef, OSType dataRefType) -> (Media _rv)")}, |
| {"GetTrackMedia", (PyCFunction)TrackObj_GetTrackMedia, 1, |
| PyDoc_STR("() -> (Media _rv)")}, |
| {"InsertMediaIntoTrack", (PyCFunction)TrackObj_InsertMediaIntoTrack, 1, |
| PyDoc_STR("(TimeValue trackStart, TimeValue mediaTime, TimeValue mediaDuration, Fixed mediaRate) -> None")}, |
| {"InsertTrackSegment", (PyCFunction)TrackObj_InsertTrackSegment, 1, |
| PyDoc_STR("(Track dstTrack, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None")}, |
| {"InsertEmptyTrackSegment", (PyCFunction)TrackObj_InsertEmptyTrackSegment, 1, |
| PyDoc_STR("(TimeValue dstIn, TimeValue dstDuration) -> None")}, |
| {"DeleteTrackSegment", (PyCFunction)TrackObj_DeleteTrackSegment, 1, |
| PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")}, |
| {"ScaleTrackSegment", (PyCFunction)TrackObj_ScaleTrackSegment, 1, |
| PyDoc_STR("(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None")}, |
| {"IsScrapMovie", (PyCFunction)TrackObj_IsScrapMovie, 1, |
| PyDoc_STR("() -> (Component _rv)")}, |
| {"CopyTrackSettings", (PyCFunction)TrackObj_CopyTrackSettings, 1, |
| PyDoc_STR("(Track dstTrack) -> None")}, |
| {"AddEmptyTrackToMovie", (PyCFunction)TrackObj_AddEmptyTrackToMovie, 1, |
| PyDoc_STR("(Movie dstMovie, Handle dataRef, OSType dataRefType) -> (Track dstTrack)")}, |
| {"AddClonedTrackToMovie", (PyCFunction)TrackObj_AddClonedTrackToMovie, 1, |
| PyDoc_STR("(Movie dstMovie, long flags) -> (Track dstTrack)")}, |
| {"AddTrackReference", (PyCFunction)TrackObj_AddTrackReference, 1, |
| PyDoc_STR("(Track refTrack, OSType refType) -> (long addedIndex)")}, |
| {"DeleteTrackReference", (PyCFunction)TrackObj_DeleteTrackReference, 1, |
| PyDoc_STR("(OSType refType, long index) -> None")}, |
| {"SetTrackReference", (PyCFunction)TrackObj_SetTrackReference, 1, |
| PyDoc_STR("(Track refTrack, OSType refType, long index) -> None")}, |
| {"GetTrackReference", (PyCFunction)TrackObj_GetTrackReference, 1, |
| PyDoc_STR("(OSType refType, long index) -> (Track _rv)")}, |
| {"GetNextTrackReferenceType", (PyCFunction)TrackObj_GetNextTrackReferenceType, 1, |
| PyDoc_STR("(OSType refType) -> (OSType _rv)")}, |
| {"GetTrackReferenceCount", (PyCFunction)TrackObj_GetTrackReferenceCount, 1, |
| PyDoc_STR("(OSType refType) -> (long _rv)")}, |
| {"GetTrackEditRate", (PyCFunction)TrackObj_GetTrackEditRate, 1, |
| PyDoc_STR("(TimeValue atTime) -> (Fixed _rv)")}, |
| {"GetTrackDataSize", (PyCFunction)TrackObj_GetTrackDataSize, 1, |
| PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")}, |
| {"GetTrackDataSize64", (PyCFunction)TrackObj_GetTrackDataSize64, 1, |
| PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")}, |
| {"PtInTrack", (PyCFunction)TrackObj_PtInTrack, 1, |
| PyDoc_STR("(Point pt) -> (Boolean _rv)")}, |
| {"GetTrackNextInterestingTime", (PyCFunction)TrackObj_GetTrackNextInterestingTime, 1, |
| PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")}, |
| {"GetTrackSegmentDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackSegmentDisplayBoundsRgn, 1, |
| PyDoc_STR("(TimeValue time, TimeValue duration) -> (RgnHandle _rv)")}, |
| {"GetTrackStatus", (PyCFunction)TrackObj_GetTrackStatus, 1, |
| PyDoc_STR("() -> (ComponentResult _rv)")}, |
| {"SetTrackLoadSettings", (PyCFunction)TrackObj_SetTrackLoadSettings, 1, |
| PyDoc_STR("(TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints) -> None")}, |
| {"GetTrackLoadSettings", (PyCFunction)TrackObj_GetTrackLoadSettings, 1, |
| PyDoc_STR("() -> (TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints)")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define TrackObj_getsetlist NULL |
| |
| |
| #define TrackObj_compare NULL |
| |
| #define TrackObj_repr NULL |
| |
| #define TrackObj_hash NULL |
| #define TrackObj_tp_init 0 |
| |
| #define TrackObj_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *TrackObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) |
| { |
| PyObject *self; |
| Track itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, TrackObj_Convert, &itself)) return NULL; |
| if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((TrackObject *)self)->ob_itself = itself; |
| return self; |
| } |
| |
| #define TrackObj_tp_free PyObject_Del |
| |
| |
| PyTypeObject Track_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_Qt.Track", /*tp_name*/ |
| sizeof(TrackObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) TrackObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*tp_setattr*/ |
| (cmpfunc) TrackObj_compare, /*tp_compare*/ |
| (reprfunc) TrackObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) TrackObj_hash, /*tp_hash*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| TrackObj_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| TrackObj_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| TrackObj_tp_init, /* tp_init */ |
| TrackObj_tp_alloc, /* tp_alloc */ |
| TrackObj_tp_new, /* tp_new */ |
| TrackObj_tp_free, /* tp_free */ |
| }; |
| |
| /* --------------------- End object type Track ---------------------- */ |
| |
| |
| /* ----------------------- Object type Movie ------------------------ */ |
| |
| PyTypeObject Movie_Type; |
| |
| #define MovieObj_Check(x) ((x)->ob_type == &Movie_Type || PyObject_TypeCheck((x), &Movie_Type)) |
| |
| typedef struct MovieObject { |
| PyObject_HEAD |
| Movie ob_itself; |
| } MovieObject; |
| |
| PyObject *MovieObj_New(Movie itself) |
| { |
| MovieObject *it; |
| if (itself == NULL) { |
| PyErr_SetString(Qt_Error,"Cannot create null Movie"); |
| return NULL; |
| } |
| it = PyObject_NEW(MovieObject, &Movie_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| return (PyObject *)it; |
| } |
| int MovieObj_Convert(PyObject *v, Movie *p_itself) |
| { |
| if (!MovieObj_Check(v)) |
| { |
| PyErr_SetString(PyExc_TypeError, "Movie required"); |
| return 0; |
| } |
| *p_itself = ((MovieObject *)v)->ob_itself; |
| return 1; |
| } |
| |
| static void MovieObj_dealloc(MovieObject *self) |
| { |
| DisposeMovie(self->ob_itself); |
| self->ob_type->tp_free((PyObject *)self); |
| } |
| |
| static PyObject *MovieObj_MoviesTask(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long maxMilliSecToUse; |
| #ifndef MoviesTask |
| PyMac_PRECHECK(MoviesTask); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &maxMilliSecToUse)) |
| return NULL; |
| MoviesTask(_self->ob_itself, |
| maxMilliSecToUse); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PrerollMovie(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue time; |
| Fixed Rate; |
| #ifndef PrerollMovie |
| PyMac_PRECHECK(PrerollMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lO&", |
| &time, |
| PyMac_GetFixed, &Rate)) |
| return NULL; |
| _err = PrerollMovie(_self->ob_itself, |
| time, |
| Rate); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_AbortPrePrerollMovie(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr err; |
| #ifndef AbortPrePrerollMovie |
| PyMac_PRECHECK(AbortPrePrerollMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &err)) |
| return NULL; |
| AbortPrePrerollMovie(_self->ob_itself, |
| err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_LoadMovieIntoRam(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue time; |
| TimeValue duration; |
| long flags; |
| #ifndef LoadMovieIntoRam |
| PyMac_PRECHECK(LoadMovieIntoRam); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lll", |
| &time, |
| &duration, |
| &flags)) |
| return NULL; |
| _err = LoadMovieIntoRam(_self->ob_itself, |
| time, |
| duration, |
| flags); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieActive(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean active; |
| #ifndef SetMovieActive |
| PyMac_PRECHECK(SetMovieActive); |
| #endif |
| if (!PyArg_ParseTuple(_args, "b", |
| &active)) |
| return NULL; |
| SetMovieActive(_self->ob_itself, |
| active); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieActive(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| #ifndef GetMovieActive |
| PyMac_PRECHECK(GetMovieActive); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieActive(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_StartMovie(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef StartMovie |
| PyMac_PRECHECK(StartMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| StartMovie(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_StopMovie(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef StopMovie |
| PyMac_PRECHECK(StopMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| StopMovie(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GoToBeginningOfMovie(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef GoToBeginningOfMovie |
| PyMac_PRECHECK(GoToBeginningOfMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GoToBeginningOfMovie(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GoToEndOfMovie(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef GoToEndOfMovie |
| PyMac_PRECHECK(GoToEndOfMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GoToEndOfMovie(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_IsMovieDone(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| #ifndef IsMovieDone |
| PyMac_PRECHECK(IsMovieDone); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = IsMovieDone(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMoviePreviewMode(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| #ifndef GetMoviePreviewMode |
| PyMac_PRECHECK(GetMoviePreviewMode); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMoviePreviewMode(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMoviePreviewMode(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean usePreview; |
| #ifndef SetMoviePreviewMode |
| PyMac_PRECHECK(SetMoviePreviewMode); |
| #endif |
| if (!PyArg_ParseTuple(_args, "b", |
| &usePreview)) |
| return NULL; |
| SetMoviePreviewMode(_self->ob_itself, |
| usePreview); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_ShowMoviePoster(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef ShowMoviePoster |
| PyMac_PRECHECK(ShowMoviePoster); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| ShowMoviePoster(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieTimeBase(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeBase _rv; |
| #ifndef GetMovieTimeBase |
| PyMac_PRECHECK(GetMovieTimeBase); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieTimeBase(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| TimeBaseObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieMasterTimeBase(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeBase tb; |
| TimeRecord slaveZero; |
| #ifndef SetMovieMasterTimeBase |
| PyMac_PRECHECK(SetMovieMasterTimeBase); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| TimeBaseObj_Convert, &tb, |
| QtTimeRecord_Convert, &slaveZero)) |
| return NULL; |
| SetMovieMasterTimeBase(_self->ob_itself, |
| tb, |
| &slaveZero); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieMasterClock(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Component clockMeister; |
| TimeRecord slaveZero; |
| #ifndef SetMovieMasterClock |
| PyMac_PRECHECK(SetMovieMasterClock); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| CmpObj_Convert, &clockMeister, |
| QtTimeRecord_Convert, &slaveZero)) |
| return NULL; |
| SetMovieMasterClock(_self->ob_itself, |
| clockMeister, |
| &slaveZero); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieGWorld(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| CGrafPtr port; |
| GDHandle gdh; |
| #ifndef GetMovieGWorld |
| PyMac_PRECHECK(GetMovieGWorld); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetMovieGWorld(_self->ob_itself, |
| &port, |
| &gdh); |
| _res = Py_BuildValue("O&O&", |
| GrafObj_New, port, |
| OptResObj_New, gdh); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieGWorld(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| CGrafPtr port; |
| GDHandle gdh; |
| #ifndef SetMovieGWorld |
| PyMac_PRECHECK(SetMovieGWorld); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| GrafObj_Convert, &port, |
| OptResObj_Convert, &gdh)) |
| return NULL; |
| SetMovieGWorld(_self->ob_itself, |
| port, |
| gdh); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieNaturalBoundsRect(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Rect naturalBounds; |
| #ifndef GetMovieNaturalBoundsRect |
| PyMac_PRECHECK(GetMovieNaturalBoundsRect); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetMovieNaturalBoundsRect(_self->ob_itself, |
| &naturalBounds); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildRect, &naturalBounds); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetNextTrackForCompositing(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| Track theTrack; |
| #ifndef GetNextTrackForCompositing |
| PyMac_PRECHECK(GetNextTrackForCompositing); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| TrackObj_Convert, &theTrack)) |
| return NULL; |
| _rv = GetNextTrackForCompositing(_self->ob_itself, |
| theTrack); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetPrevTrackForCompositing(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| Track theTrack; |
| #ifndef GetPrevTrackForCompositing |
| PyMac_PRECHECK(GetPrevTrackForCompositing); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| TrackObj_Convert, &theTrack)) |
| return NULL; |
| _rv = GetPrevTrackForCompositing(_self->ob_itself, |
| theTrack); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMoviePict(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| PicHandle _rv; |
| TimeValue time; |
| #ifndef GetMoviePict |
| PyMac_PRECHECK(GetMoviePict); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &time)) |
| return NULL; |
| _rv = GetMoviePict(_self->ob_itself, |
| time); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMoviePosterPict(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| PicHandle _rv; |
| #ifndef GetMoviePosterPict |
| PyMac_PRECHECK(GetMoviePosterPict); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMoviePosterPict(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_UpdateMovie(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| #ifndef UpdateMovie |
| PyMac_PRECHECK(UpdateMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = UpdateMovie(_self->ob_itself); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_InvalidateMovieRegion(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| RgnHandle invalidRgn; |
| #ifndef InvalidateMovieRegion |
| PyMac_PRECHECK(InvalidateMovieRegion); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &invalidRgn)) |
| return NULL; |
| _err = InvalidateMovieRegion(_self->ob_itself, |
| invalidRgn); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieBox(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Rect boxRect; |
| #ifndef GetMovieBox |
| PyMac_PRECHECK(GetMovieBox); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetMovieBox(_self->ob_itself, |
| &boxRect); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildRect, &boxRect); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieBox(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Rect boxRect; |
| #ifndef SetMovieBox |
| PyMac_PRECHECK(SetMovieBox); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetRect, &boxRect)) |
| return NULL; |
| SetMovieBox(_self->ob_itself, |
| &boxRect); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieDisplayClipRgn(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| #ifndef GetMovieDisplayClipRgn |
| PyMac_PRECHECK(GetMovieDisplayClipRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieDisplayClipRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieDisplayClipRgn(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle theClip; |
| #ifndef SetMovieDisplayClipRgn |
| PyMac_PRECHECK(SetMovieDisplayClipRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &theClip)) |
| return NULL; |
| SetMovieDisplayClipRgn(_self->ob_itself, |
| theClip); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieClipRgn(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| #ifndef GetMovieClipRgn |
| PyMac_PRECHECK(GetMovieClipRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieClipRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieClipRgn(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle theClip; |
| #ifndef SetMovieClipRgn |
| PyMac_PRECHECK(SetMovieClipRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &theClip)) |
| return NULL; |
| SetMovieClipRgn(_self->ob_itself, |
| theClip); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieDisplayBoundsRgn(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| #ifndef GetMovieDisplayBoundsRgn |
| PyMac_PRECHECK(GetMovieDisplayBoundsRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieDisplayBoundsRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieBoundsRgn(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| #ifndef GetMovieBoundsRgn |
| PyMac_PRECHECK(GetMovieBoundsRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieBoundsRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieVideoOutput(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentInstance vout; |
| #ifndef SetMovieVideoOutput |
| PyMac_PRECHECK(SetMovieVideoOutput); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpInstObj_Convert, &vout)) |
| return NULL; |
| SetMovieVideoOutput(_self->ob_itself, |
| vout); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PutMovieIntoHandle(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle publicMovie; |
| #ifndef PutMovieIntoHandle |
| PyMac_PRECHECK(PutMovieIntoHandle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &publicMovie)) |
| return NULL; |
| _err = PutMovieIntoHandle(_self->ob_itself, |
| publicMovie); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PutMovieIntoDataFork(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short fRefNum; |
| long offset; |
| long maxSize; |
| #ifndef PutMovieIntoDataFork |
| PyMac_PRECHECK(PutMovieIntoDataFork); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hll", |
| &fRefNum, |
| &offset, |
| &maxSize)) |
| return NULL; |
| _err = PutMovieIntoDataFork(_self->ob_itself, |
| fRefNum, |
| offset, |
| maxSize); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PutMovieIntoDataFork64(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long fRefNum; |
| wide offset; |
| unsigned long maxSize; |
| #ifndef PutMovieIntoDataFork64 |
| PyMac_PRECHECK(PutMovieIntoDataFork64); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lO&l", |
| &fRefNum, |
| PyMac_Getwide, &offset, |
| &maxSize)) |
| return NULL; |
| _err = PutMovieIntoDataFork64(_self->ob_itself, |
| fRefNum, |
| &offset, |
| maxSize); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieCreationTime(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| unsigned long _rv; |
| #ifndef GetMovieCreationTime |
| PyMac_PRECHECK(GetMovieCreationTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieCreationTime(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieModificationTime(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| unsigned long _rv; |
| #ifndef GetMovieModificationTime |
| PyMac_PRECHECK(GetMovieModificationTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieModificationTime(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieTimeScale(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeScale _rv; |
| #ifndef GetMovieTimeScale |
| PyMac_PRECHECK(GetMovieTimeScale); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieTimeScale(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieTimeScale(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeScale timeScale; |
| #ifndef SetMovieTimeScale |
| PyMac_PRECHECK(SetMovieTimeScale); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &timeScale)) |
| return NULL; |
| SetMovieTimeScale(_self->ob_itself, |
| timeScale); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieDuration(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| #ifndef GetMovieDuration |
| PyMac_PRECHECK(GetMovieDuration); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieDuration(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieRate(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Fixed _rv; |
| #ifndef GetMovieRate |
| PyMac_PRECHECK(GetMovieRate); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieRate(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildFixed, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieRate(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Fixed rate; |
| #ifndef SetMovieRate |
| PyMac_PRECHECK(SetMovieRate); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetFixed, &rate)) |
| return NULL; |
| SetMovieRate(_self->ob_itself, |
| rate); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMoviePreferredRate(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Fixed _rv; |
| #ifndef GetMoviePreferredRate |
| PyMac_PRECHECK(GetMoviePreferredRate); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMoviePreferredRate(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildFixed, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMoviePreferredRate(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Fixed rate; |
| #ifndef SetMoviePreferredRate |
| PyMac_PRECHECK(SetMoviePreferredRate); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetFixed, &rate)) |
| return NULL; |
| SetMoviePreferredRate(_self->ob_itself, |
| rate); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMoviePreferredVolume(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| #ifndef GetMoviePreferredVolume |
| PyMac_PRECHECK(GetMoviePreferredVolume); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMoviePreferredVolume(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMoviePreferredVolume(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short volume; |
| #ifndef SetMoviePreferredVolume |
| PyMac_PRECHECK(SetMoviePreferredVolume); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &volume)) |
| return NULL; |
| SetMoviePreferredVolume(_self->ob_itself, |
| volume); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieVolume(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| #ifndef GetMovieVolume |
| PyMac_PRECHECK(GetMovieVolume); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieVolume(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieVolume(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short volume; |
| #ifndef SetMovieVolume |
| PyMac_PRECHECK(SetMovieVolume); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &volume)) |
| return NULL; |
| SetMovieVolume(_self->ob_itself, |
| volume); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMoviePreviewTime(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue previewTime; |
| TimeValue previewDuration; |
| #ifndef GetMoviePreviewTime |
| PyMac_PRECHECK(GetMoviePreviewTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetMoviePreviewTime(_self->ob_itself, |
| &previewTime, |
| &previewDuration); |
| _res = Py_BuildValue("ll", |
| previewTime, |
| previewDuration); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMoviePreviewTime(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue previewTime; |
| TimeValue previewDuration; |
| #ifndef SetMoviePreviewTime |
| PyMac_PRECHECK(SetMoviePreviewTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &previewTime, |
| &previewDuration)) |
| return NULL; |
| SetMoviePreviewTime(_self->ob_itself, |
| previewTime, |
| previewDuration); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMoviePosterTime(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| #ifndef GetMoviePosterTime |
| PyMac_PRECHECK(GetMoviePosterTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMoviePosterTime(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMoviePosterTime(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue posterTime; |
| #ifndef SetMoviePosterTime |
| PyMac_PRECHECK(SetMoviePosterTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &posterTime)) |
| return NULL; |
| SetMoviePosterTime(_self->ob_itself, |
| posterTime); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieSelection(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue selectionTime; |
| TimeValue selectionDuration; |
| #ifndef GetMovieSelection |
| PyMac_PRECHECK(GetMovieSelection); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetMovieSelection(_self->ob_itself, |
| &selectionTime, |
| &selectionDuration); |
| _res = Py_BuildValue("ll", |
| selectionTime, |
| selectionDuration); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieSelection(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue selectionTime; |
| TimeValue selectionDuration; |
| #ifndef SetMovieSelection |
| PyMac_PRECHECK(SetMovieSelection); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &selectionTime, |
| &selectionDuration)) |
| return NULL; |
| SetMovieSelection(_self->ob_itself, |
| selectionTime, |
| selectionDuration); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieActiveSegment(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue startTime; |
| TimeValue duration; |
| #ifndef SetMovieActiveSegment |
| PyMac_PRECHECK(SetMovieActiveSegment); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| SetMovieActiveSegment(_self->ob_itself, |
| startTime, |
| duration); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieActiveSegment(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue startTime; |
| TimeValue duration; |
| #ifndef GetMovieActiveSegment |
| PyMac_PRECHECK(GetMovieActiveSegment); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetMovieActiveSegment(_self->ob_itself, |
| &startTime, |
| &duration); |
| _res = Py_BuildValue("ll", |
| startTime, |
| duration); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieTime(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| TimeRecord currentTime; |
| #ifndef GetMovieTime |
| PyMac_PRECHECK(GetMovieTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieTime(_self->ob_itself, |
| ¤tTime); |
| _res = Py_BuildValue("lO&", |
| _rv, |
| QtTimeRecord_New, ¤tTime); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieTime(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeRecord newtime; |
| #ifndef SetMovieTime |
| PyMac_PRECHECK(SetMovieTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| QtTimeRecord_Convert, &newtime)) |
| return NULL; |
| SetMovieTime(_self->ob_itself, |
| &newtime); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieTimeValue(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue newtime; |
| #ifndef SetMovieTimeValue |
| PyMac_PRECHECK(SetMovieTimeValue); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &newtime)) |
| return NULL; |
| SetMovieTimeValue(_self->ob_itself, |
| newtime); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieUserData(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| UserData _rv; |
| #ifndef GetMovieUserData |
| PyMac_PRECHECK(GetMovieUserData); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieUserData(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| UserDataObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieTrackCount(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| #ifndef GetMovieTrackCount |
| PyMac_PRECHECK(GetMovieTrackCount); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieTrackCount(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieTrack(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| long trackID; |
| #ifndef GetMovieTrack |
| PyMac_PRECHECK(GetMovieTrack); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &trackID)) |
| return NULL; |
| _rv = GetMovieTrack(_self->ob_itself, |
| trackID); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieIndTrack(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| long index; |
| #ifndef GetMovieIndTrack |
| PyMac_PRECHECK(GetMovieIndTrack); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &index)) |
| return NULL; |
| _rv = GetMovieIndTrack(_self->ob_itself, |
| index); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieIndTrackType(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| long index; |
| OSType trackType; |
| long flags; |
| #ifndef GetMovieIndTrackType |
| PyMac_PRECHECK(GetMovieIndTrackType); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lO&l", |
| &index, |
| PyMac_GetOSType, &trackType, |
| &flags)) |
| return NULL; |
| _rv = GetMovieIndTrackType(_self->ob_itself, |
| index, |
| trackType, |
| flags); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_NewMovieTrack(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| Fixed width; |
| Fixed height; |
| short trackVolume; |
| #ifndef NewMovieTrack |
| PyMac_PRECHECK(NewMovieTrack); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&h", |
| PyMac_GetFixed, &width, |
| PyMac_GetFixed, &height, |
| &trackVolume)) |
| return NULL; |
| _rv = NewMovieTrack(_self->ob_itself, |
| width, |
| height, |
| trackVolume); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetAutoTrackAlternatesEnabled(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean enable; |
| #ifndef SetAutoTrackAlternatesEnabled |
| PyMac_PRECHECK(SetAutoTrackAlternatesEnabled); |
| #endif |
| if (!PyArg_ParseTuple(_args, "b", |
| &enable)) |
| return NULL; |
| SetAutoTrackAlternatesEnabled(_self->ob_itself, |
| enable); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SelectMovieAlternates(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef SelectMovieAlternates |
| PyMac_PRECHECK(SelectMovieAlternates); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| SelectMovieAlternates(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_InsertMovieSegment(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie dstMovie; |
| TimeValue srcIn; |
| TimeValue srcDuration; |
| TimeValue dstIn; |
| #ifndef InsertMovieSegment |
| PyMac_PRECHECK(InsertMovieSegment); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&lll", |
| MovieObj_Convert, &dstMovie, |
| &srcIn, |
| &srcDuration, |
| &dstIn)) |
| return NULL; |
| _err = InsertMovieSegment(_self->ob_itself, |
| dstMovie, |
| srcIn, |
| srcDuration, |
| dstIn); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_InsertEmptyMovieSegment(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue dstIn; |
| TimeValue dstDuration; |
| #ifndef InsertEmptyMovieSegment |
| PyMac_PRECHECK(InsertEmptyMovieSegment); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &dstIn, |
| &dstDuration)) |
| return NULL; |
| _err = InsertEmptyMovieSegment(_self->ob_itself, |
| dstIn, |
| dstDuration); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_DeleteMovieSegment(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue startTime; |
| TimeValue duration; |
| #ifndef DeleteMovieSegment |
| PyMac_PRECHECK(DeleteMovieSegment); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| _err = DeleteMovieSegment(_self->ob_itself, |
| startTime, |
| duration); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_ScaleMovieSegment(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue startTime; |
| TimeValue oldDuration; |
| TimeValue newDuration; |
| #ifndef ScaleMovieSegment |
| PyMac_PRECHECK(ScaleMovieSegment); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lll", |
| &startTime, |
| &oldDuration, |
| &newDuration)) |
| return NULL; |
| _err = ScaleMovieSegment(_self->ob_itself, |
| startTime, |
| oldDuration, |
| newDuration); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_CutMovieSelection(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| #ifndef CutMovieSelection |
| PyMac_PRECHECK(CutMovieSelection); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = CutMovieSelection(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_CopyMovieSelection(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| #ifndef CopyMovieSelection |
| PyMac_PRECHECK(CopyMovieSelection); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = CopyMovieSelection(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PasteMovieSelection(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Movie src; |
| #ifndef PasteMovieSelection |
| PyMac_PRECHECK(PasteMovieSelection); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| MovieObj_Convert, &src)) |
| return NULL; |
| PasteMovieSelection(_self->ob_itself, |
| src); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_AddMovieSelection(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Movie src; |
| #ifndef AddMovieSelection |
| PyMac_PRECHECK(AddMovieSelection); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| MovieObj_Convert, &src)) |
| return NULL; |
| AddMovieSelection(_self->ob_itself, |
| src); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_ClearMovieSelection(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef ClearMovieSelection |
| PyMac_PRECHECK(ClearMovieSelection); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| ClearMovieSelection(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PutMovieIntoTypedHandle(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Track targetTrack; |
| OSType handleType; |
| Handle publicMovie; |
| TimeValue start; |
| TimeValue dur; |
| long flags; |
| ComponentInstance userComp; |
| #ifndef PutMovieIntoTypedHandle |
| PyMac_PRECHECK(PutMovieIntoTypedHandle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&lllO&", |
| TrackObj_Convert, &targetTrack, |
| PyMac_GetOSType, &handleType, |
| ResObj_Convert, &publicMovie, |
| &start, |
| &dur, |
| &flags, |
| CmpInstObj_Convert, &userComp)) |
| return NULL; |
| _err = PutMovieIntoTypedHandle(_self->ob_itself, |
| targetTrack, |
| handleType, |
| publicMovie, |
| start, |
| dur, |
| flags, |
| userComp); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_CopyMovieSettings(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie dstMovie; |
| #ifndef CopyMovieSettings |
| PyMac_PRECHECK(CopyMovieSettings); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| MovieObj_Convert, &dstMovie)) |
| return NULL; |
| _err = CopyMovieSettings(_self->ob_itself, |
| dstMovie); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_ConvertMovieToFile(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Track onlyTrack; |
| FSSpec outputFile; |
| OSType fileType; |
| OSType creator; |
| ScriptCode scriptTag; |
| short resID; |
| long flags; |
| ComponentInstance userComp; |
| #ifndef ConvertMovieToFile |
| PyMac_PRECHECK(ConvertMovieToFile); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&O&hlO&", |
| TrackObj_Convert, &onlyTrack, |
| PyMac_GetFSSpec, &outputFile, |
| PyMac_GetOSType, &fileType, |
| PyMac_GetOSType, &creator, |
| &scriptTag, |
| &flags, |
| CmpInstObj_Convert, &userComp)) |
| return NULL; |
| _err = ConvertMovieToFile(_self->ob_itself, |
| onlyTrack, |
| &outputFile, |
| fileType, |
| creator, |
| scriptTag, |
| &resID, |
| flags, |
| userComp); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| resID); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieDataSize(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| TimeValue startTime; |
| TimeValue duration; |
| #ifndef GetMovieDataSize |
| PyMac_PRECHECK(GetMovieDataSize); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| _rv = GetMovieDataSize(_self->ob_itself, |
| startTime, |
| duration); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieDataSize64(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue startTime; |
| TimeValue duration; |
| wide dataSize; |
| #ifndef GetMovieDataSize64 |
| PyMac_PRECHECK(GetMovieDataSize64); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| _err = GetMovieDataSize64(_self->ob_itself, |
| startTime, |
| duration, |
| &dataSize); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| PyMac_Buildwide, dataSize); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PtInMovie(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| Point pt; |
| #ifndef PtInMovie |
| PyMac_PRECHECK(PtInMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetPoint, &pt)) |
| return NULL; |
| _rv = PtInMovie(_self->ob_itself, |
| pt); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieLanguage(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long language; |
| #ifndef SetMovieLanguage |
| PyMac_PRECHECK(SetMovieLanguage); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &language)) |
| return NULL; |
| SetMovieLanguage(_self->ob_itself, |
| language); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieNextInterestingTime(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| short interestingTimeFlags; |
| short numMediaTypes; |
| OSType whichMediaTypes; |
| TimeValue time; |
| Fixed rate; |
| TimeValue interestingTime; |
| TimeValue interestingDuration; |
| #ifndef GetMovieNextInterestingTime |
| PyMac_PRECHECK(GetMovieNextInterestingTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hhO&lO&", |
| &interestingTimeFlags, |
| &numMediaTypes, |
| PyMac_GetOSType, &whichMediaTypes, |
| &time, |
| PyMac_GetFixed, &rate)) |
| return NULL; |
| GetMovieNextInterestingTime(_self->ob_itself, |
| interestingTimeFlags, |
| numMediaTypes, |
| &whichMediaTypes, |
| time, |
| rate, |
| &interestingTime, |
| &interestingDuration); |
| _res = Py_BuildValue("ll", |
| interestingTime, |
| interestingDuration); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_AddMovieResource(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short resRefNum; |
| short resId; |
| Str255 resName; |
| #ifndef AddMovieResource |
| PyMac_PRECHECK(AddMovieResource); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hO&", |
| &resRefNum, |
| PyMac_GetStr255, resName)) |
| return NULL; |
| _err = AddMovieResource(_self->ob_itself, |
| resRefNum, |
| &resId, |
| resName); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| resId); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_UpdateMovieResource(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short resRefNum; |
| short resId; |
| Str255 resName; |
| #ifndef UpdateMovieResource |
| PyMac_PRECHECK(UpdateMovieResource); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hhO&", |
| &resRefNum, |
| &resId, |
| PyMac_GetStr255, resName)) |
| return NULL; |
| _err = UpdateMovieResource(_self->ob_itself, |
| resRefNum, |
| resId, |
| resName); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_HasMovieChanged(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| #ifndef HasMovieChanged |
| PyMac_PRECHECK(HasMovieChanged); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = HasMovieChanged(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_ClearMovieChanged(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef ClearMovieChanged |
| PyMac_PRECHECK(ClearMovieChanged); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| ClearMovieChanged(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieDefaultDataRef(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle dataRef; |
| OSType dataRefType; |
| #ifndef SetMovieDefaultDataRef |
| PyMac_PRECHECK(SetMovieDefaultDataRef); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| ResObj_Convert, &dataRef, |
| PyMac_GetOSType, &dataRefType)) |
| return NULL; |
| _err = SetMovieDefaultDataRef(_self->ob_itself, |
| dataRef, |
| dataRefType); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieDefaultDataRef(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle dataRef; |
| OSType dataRefType; |
| #ifndef GetMovieDefaultDataRef |
| PyMac_PRECHECK(GetMovieDefaultDataRef); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetMovieDefaultDataRef(_self->ob_itself, |
| &dataRef, |
| &dataRefType); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&O&", |
| ResObj_New, dataRef, |
| PyMac_BuildOSType, dataRefType); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieColorTable(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| CTabHandle ctab; |
| #ifndef SetMovieColorTable |
| PyMac_PRECHECK(SetMovieColorTable); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &ctab)) |
| return NULL; |
| _err = SetMovieColorTable(_self->ob_itself, |
| ctab); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieColorTable(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| CTabHandle ctab; |
| #ifndef GetMovieColorTable |
| PyMac_PRECHECK(GetMovieColorTable); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetMovieColorTable(_self->ob_itself, |
| &ctab); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| ResObj_New, ctab); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_FlattenMovie(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long movieFlattenFlags; |
| FSSpec theFile; |
| OSType creator; |
| ScriptCode scriptTag; |
| long createMovieFileFlags; |
| short resId; |
| Str255 resName; |
| #ifndef FlattenMovie |
| PyMac_PRECHECK(FlattenMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lO&O&hlO&", |
| &movieFlattenFlags, |
| PyMac_GetFSSpec, &theFile, |
| PyMac_GetOSType, &creator, |
| &scriptTag, |
| &createMovieFileFlags, |
| PyMac_GetStr255, resName)) |
| return NULL; |
| FlattenMovie(_self->ob_itself, |
| movieFlattenFlags, |
| &theFile, |
| creator, |
| scriptTag, |
| createMovieFileFlags, |
| &resId, |
| resName); |
| _res = Py_BuildValue("h", |
| resId); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_FlattenMovieData(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| long movieFlattenFlags; |
| FSSpec theFile; |
| OSType creator; |
| ScriptCode scriptTag; |
| long createMovieFileFlags; |
| #ifndef FlattenMovieData |
| PyMac_PRECHECK(FlattenMovieData); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lO&O&hl", |
| &movieFlattenFlags, |
| PyMac_GetFSSpec, &theFile, |
| PyMac_GetOSType, &creator, |
| &scriptTag, |
| &createMovieFileFlags)) |
| return NULL; |
| _rv = FlattenMovieData(_self->ob_itself, |
| movieFlattenFlags, |
| &theFile, |
| creator, |
| scriptTag, |
| createMovieFileFlags); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_MovieSearchText(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Ptr text; |
| long size; |
| long searchFlags; |
| Track searchTrack; |
| TimeValue searchTime; |
| long searchOffset; |
| #ifndef MovieSearchText |
| PyMac_PRECHECK(MovieSearchText); |
| #endif |
| if (!PyArg_ParseTuple(_args, "sll", |
| &text, |
| &size, |
| &searchFlags)) |
| return NULL; |
| _err = MovieSearchText(_self->ob_itself, |
| text, |
| size, |
| searchFlags, |
| &searchTrack, |
| &searchTime, |
| &searchOffset); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&ll", |
| TrackObj_New, searchTrack, |
| searchTime, |
| searchOffset); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetPosterBox(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Rect boxRect; |
| #ifndef GetPosterBox |
| PyMac_PRECHECK(GetPosterBox); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetPosterBox(_self->ob_itself, |
| &boxRect); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildRect, &boxRect); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetPosterBox(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Rect boxRect; |
| #ifndef SetPosterBox |
| PyMac_PRECHECK(SetPosterBox); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetRect, &boxRect)) |
| return NULL; |
| SetPosterBox(_self->ob_itself, |
| &boxRect); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieSegmentDisplayBoundsRgn(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| TimeValue time; |
| TimeValue duration; |
| #ifndef GetMovieSegmentDisplayBoundsRgn |
| PyMac_PRECHECK(GetMovieSegmentDisplayBoundsRgn); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &time, |
| &duration)) |
| return NULL; |
| _rv = GetMovieSegmentDisplayBoundsRgn(_self->ob_itself, |
| time, |
| duration); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieStatus(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Track firstProblemTrack; |
| #ifndef GetMovieStatus |
| PyMac_PRECHECK(GetMovieStatus); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieStatus(_self->ob_itself, |
| &firstProblemTrack); |
| _res = Py_BuildValue("lO&", |
| _rv, |
| TrackObj_New, firstProblemTrack); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_NewMovieController(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| MovieController _rv; |
| Rect movieRect; |
| long someFlags; |
| #ifndef NewMovieController |
| PyMac_PRECHECK(NewMovieController); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| PyMac_GetRect, &movieRect, |
| &someFlags)) |
| return NULL; |
| _rv = NewMovieController(_self->ob_itself, |
| &movieRect, |
| someFlags); |
| _res = Py_BuildValue("O&", |
| MovieCtlObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PutMovieOnScrap(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long movieScrapFlags; |
| #ifndef PutMovieOnScrap |
| PyMac_PRECHECK(PutMovieOnScrap); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &movieScrapFlags)) |
| return NULL; |
| _err = PutMovieOnScrap(_self->ob_itself, |
| movieScrapFlags); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMoviePlayHints(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long flags; |
| long flagsMask; |
| #ifndef SetMoviePlayHints |
| PyMac_PRECHECK(SetMoviePlayHints); |
| #endif |
| if (!PyArg_ParseTuple(_args, "ll", |
| &flags, |
| &flagsMask)) |
| return NULL; |
| SetMoviePlayHints(_self->ob_itself, |
| flags, |
| flagsMask); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMaxLoadedTimeInMovie(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue time; |
| #ifndef GetMaxLoadedTimeInMovie |
| PyMac_PRECHECK(GetMaxLoadedTimeInMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetMaxLoadedTimeInMovie(_self->ob_itself, |
| &time); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| time); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_QTMovieNeedsTimeTable(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Boolean needsTimeTable; |
| #ifndef QTMovieNeedsTimeTable |
| PyMac_PRECHECK(QTMovieNeedsTimeTable); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = QTMovieNeedsTimeTable(_self->ob_itself, |
| &needsTimeTable); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("b", |
| needsTimeTable); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_QTGetDataRefMaxFileOffset(MovieObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| OSType dataRefType; |
| Handle dataRef; |
| long offset; |
| #ifndef QTGetDataRefMaxFileOffset |
| PyMac_PRECHECK(QTGetDataRefMaxFileOffset); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| PyMac_GetOSType, &dataRefType, |
| ResObj_Convert, &dataRef)) |
| return NULL; |
| _err = QTGetDataRefMaxFileOffset(_self->ob_itself, |
| dataRefType, |
| dataRef, |
| &offset); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| offset); |
| return _res; |
| } |
| |
| static PyMethodDef MovieObj_methods[] = { |
| {"MoviesTask", (PyCFunction)MovieObj_MoviesTask, 1, |
| PyDoc_STR("(long maxMilliSecToUse) -> None")}, |
| {"PrerollMovie", (PyCFunction)MovieObj_PrerollMovie, 1, |
| PyDoc_STR("(TimeValue time, Fixed Rate) -> None")}, |
| {"AbortPrePrerollMovie", (PyCFunction)MovieObj_AbortPrePrerollMovie, 1, |
| PyDoc_STR("(OSErr err) -> None")}, |
| {"LoadMovieIntoRam", (PyCFunction)MovieObj_LoadMovieIntoRam, 1, |
| PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")}, |
| {"SetMovieActive", (PyCFunction)MovieObj_SetMovieActive, 1, |
| PyDoc_STR("(Boolean active) -> None")}, |
| {"GetMovieActive", (PyCFunction)MovieObj_GetMovieActive, 1, |
| PyDoc_STR("() -> (Boolean _rv)")}, |
| {"StartMovie", (PyCFunction)MovieObj_StartMovie, 1, |
| PyDoc_STR("() -> None")}, |
| {"StopMovie", (PyCFunction)MovieObj_StopMovie, 1, |
| PyDoc_STR("() -> None")}, |
| {"GoToBeginningOfMovie", (PyCFunction)MovieObj_GoToBeginningOfMovie, 1, |
| PyDoc_STR("() -> None")}, |
| {"GoToEndOfMovie", (PyCFunction)MovieObj_GoToEndOfMovie, 1, |
| PyDoc_STR("() -> None")}, |
| {"IsMovieDone", (PyCFunction)MovieObj_IsMovieDone, 1, |
| PyDoc_STR("() -> (Boolean _rv)")}, |
| {"GetMoviePreviewMode", (PyCFunction)MovieObj_GetMoviePreviewMode, 1, |
| PyDoc_STR("() -> (Boolean _rv)")}, |
| {"SetMoviePreviewMode", (PyCFunction)MovieObj_SetMoviePreviewMode, 1, |
| PyDoc_STR("(Boolean usePreview) -> None")}, |
| {"ShowMoviePoster", (PyCFunction)MovieObj_ShowMoviePoster, 1, |
| PyDoc_STR("() -> None")}, |
| {"GetMovieTimeBase", (PyCFunction)MovieObj_GetMovieTimeBase, 1, |
| PyDoc_STR("() -> (TimeBase _rv)")}, |
| {"SetMovieMasterTimeBase", (PyCFunction)MovieObj_SetMovieMasterTimeBase, 1, |
| PyDoc_STR("(TimeBase tb, TimeRecord slaveZero) -> None")}, |
| {"SetMovieMasterClock", (PyCFunction)MovieObj_SetMovieMasterClock, 1, |
| PyDoc_STR("(Component clockMeister, TimeRecord slaveZero) -> None")}, |
| {"GetMovieGWorld", (PyCFunction)MovieObj_GetMovieGWorld, 1, |
| PyDoc_STR("() -> (CGrafPtr port, GDHandle gdh)")}, |
| {"SetMovieGWorld", (PyCFunction)MovieObj_SetMovieGWorld, 1, |
| PyDoc_STR("(CGrafPtr port, GDHandle gdh) -> None")}, |
| {"GetMovieNaturalBoundsRect", (PyCFunction)MovieObj_GetMovieNaturalBoundsRect, 1, |
| PyDoc_STR("() -> (Rect naturalBounds)")}, |
| {"GetNextTrackForCompositing", (PyCFunction)MovieObj_GetNextTrackForCompositing, 1, |
| PyDoc_STR("(Track theTrack) -> (Track _rv)")}, |
| {"GetPrevTrackForCompositing", (PyCFunction)MovieObj_GetPrevTrackForCompositing, 1, |
| PyDoc_STR("(Track theTrack) -> (Track _rv)")}, |
| {"GetMoviePict", (PyCFunction)MovieObj_GetMoviePict, 1, |
| PyDoc_STR("(TimeValue time) -> (PicHandle _rv)")}, |
| {"GetMoviePosterPict", (PyCFunction)MovieObj_GetMoviePosterPict, 1, |
| PyDoc_STR("() -> (PicHandle _rv)")}, |
| {"UpdateMovie", (PyCFunction)MovieObj_UpdateMovie, 1, |
| PyDoc_STR("() -> None")}, |
| {"InvalidateMovieRegion", (PyCFunction)MovieObj_InvalidateMovieRegion, 1, |
| PyDoc_STR("(RgnHandle invalidRgn) -> None")}, |
| {"GetMovieBox", (PyCFunction)MovieObj_GetMovieBox, 1, |
| PyDoc_STR("() -> (Rect boxRect)")}, |
| {"SetMovieBox", (PyCFunction)MovieObj_SetMovieBox, 1, |
| PyDoc_STR("(Rect boxRect) -> None")}, |
| {"GetMovieDisplayClipRgn", (PyCFunction)MovieObj_GetMovieDisplayClipRgn, 1, |
| PyDoc_STR("() -> (RgnHandle _rv)")}, |
| {"SetMovieDisplayClipRgn", (PyCFunction)MovieObj_SetMovieDisplayClipRgn, 1, |
| PyDoc_STR("(RgnHandle theClip) -> None")}, |
| {"GetMovieClipRgn", (PyCFunction)MovieObj_GetMovieClipRgn, 1, |
| PyDoc_STR("() -> (RgnHandle _rv)")}, |
| {"SetMovieClipRgn", (PyCFunction)MovieObj_SetMovieClipRgn, 1, |
| PyDoc_STR("(RgnHandle theClip) -> None")}, |
| {"GetMovieDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieDisplayBoundsRgn, 1, |
| PyDoc_STR("() -> (RgnHandle _rv)")}, |
| {"GetMovieBoundsRgn", (PyCFunction)MovieObj_GetMovieBoundsRgn, 1, |
| PyDoc_STR("() -> (RgnHandle _rv)")}, |
| {"SetMovieVideoOutput", (PyCFunction)MovieObj_SetMovieVideoOutput, 1, |
| PyDoc_STR("(ComponentInstance vout) -> None")}, |
| {"PutMovieIntoHandle", (PyCFunction)MovieObj_PutMovieIntoHandle, 1, |
| PyDoc_STR("(Handle publicMovie) -> None")}, |
| {"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1, |
| PyDoc_STR("(short fRefNum, long offset, long maxSize) -> None")}, |
| {"PutMovieIntoDataFork64", (PyCFunction)MovieObj_PutMovieIntoDataFork64, 1, |
| PyDoc_STR("(long fRefNum, wide offset, unsigned long maxSize) -> None")}, |
| {"GetMovieCreationTime", (PyCFunction)MovieObj_GetMovieCreationTime, 1, |
| PyDoc_STR("() -> (unsigned long _rv)")}, |
| {"GetMovieModificationTime", (PyCFunction)MovieObj_GetMovieModificationTime, 1, |
| PyDoc_STR("() -> (unsigned long _rv)")}, |
| {"GetMovieTimeScale", (PyCFunction)MovieObj_GetMovieTimeScale, 1, |
| PyDoc_STR("() -> (TimeScale _rv)")}, |
| {"SetMovieTimeScale", (PyCFunction)MovieObj_SetMovieTimeScale, 1, |
| PyDoc_STR("(TimeScale timeScale) -> None")}, |
| {"GetMovieDuration", (PyCFunction)MovieObj_GetMovieDuration, 1, |
| PyDoc_STR("() -> (TimeValue _rv)")}, |
| {"GetMovieRate", (PyCFunction)MovieObj_GetMovieRate, 1, |
| PyDoc_STR("() -> (Fixed _rv)")}, |
| {"SetMovieRate", (PyCFunction)MovieObj_SetMovieRate, 1, |
| PyDoc_STR("(Fixed rate) -> None")}, |
| {"GetMoviePreferredRate", (PyCFunction)MovieObj_GetMoviePreferredRate, 1, |
| PyDoc_STR("() -> (Fixed _rv)")}, |
| {"SetMoviePreferredRate", (PyCFunction)MovieObj_SetMoviePreferredRate, 1, |
| PyDoc_STR("(Fixed rate) -> None")}, |
| {"GetMoviePreferredVolume", (PyCFunction)MovieObj_GetMoviePreferredVolume, 1, |
| PyDoc_STR("() -> (short _rv)")}, |
| {"SetMoviePreferredVolume", (PyCFunction)MovieObj_SetMoviePreferredVolume, 1, |
| PyDoc_STR("(short volume) -> None")}, |
| {"GetMovieVolume", (PyCFunction)MovieObj_GetMovieVolume, 1, |
| PyDoc_STR("() -> (short _rv)")}, |
| {"SetMovieVolume", (PyCFunction)MovieObj_SetMovieVolume, 1, |
| PyDoc_STR("(short volume) -> None")}, |
| {"GetMoviePreviewTime", (PyCFunction)MovieObj_GetMoviePreviewTime, 1, |
| PyDoc_STR("() -> (TimeValue previewTime, TimeValue previewDuration)")}, |
| {"SetMoviePreviewTime", (PyCFunction)MovieObj_SetMoviePreviewTime, 1, |
| PyDoc_STR("(TimeValue previewTime, TimeValue previewDuration) -> None")}, |
| {"GetMoviePosterTime", (PyCFunction)MovieObj_GetMoviePosterTime, 1, |
| PyDoc_STR("() -> (TimeValue _rv)")}, |
| {"SetMoviePosterTime", (PyCFunction)MovieObj_SetMoviePosterTime, 1, |
| PyDoc_STR("(TimeValue posterTime) -> None")}, |
| {"GetMovieSelection", (PyCFunction)MovieObj_GetMovieSelection, 1, |
| PyDoc_STR("() -> (TimeValue selectionTime, TimeValue selectionDuration)")}, |
| {"SetMovieSelection", (PyCFunction)MovieObj_SetMovieSelection, 1, |
| PyDoc_STR("(TimeValue selectionTime, TimeValue selectionDuration) -> None")}, |
| {"SetMovieActiveSegment", (PyCFunction)MovieObj_SetMovieActiveSegment, 1, |
| PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")}, |
| {"GetMovieActiveSegment", (PyCFunction)MovieObj_GetMovieActiveSegment, 1, |
| PyDoc_STR("() -> (TimeValue startTime, TimeValue duration)")}, |
| {"GetMovieTime", (PyCFunction)MovieObj_GetMovieTime, 1, |
| PyDoc_STR("() -> (TimeValue _rv, TimeRecord currentTime)")}, |
| {"SetMovieTime", (PyCFunction)MovieObj_SetMovieTime, 1, |
| PyDoc_STR("(TimeRecord newtime) -> None")}, |
| {"SetMovieTimeValue", (PyCFunction)MovieObj_SetMovieTimeValue, 1, |
| PyDoc_STR("(TimeValue newtime) -> None")}, |
| {"GetMovieUserData", (PyCFunction)MovieObj_GetMovieUserData, 1, |
| PyDoc_STR("() -> (UserData _rv)")}, |
| {"GetMovieTrackCount", (PyCFunction)MovieObj_GetMovieTrackCount, 1, |
| PyDoc_STR("() -> (long _rv)")}, |
| {"GetMovieTrack", (PyCFunction)MovieObj_GetMovieTrack, 1, |
| PyDoc_STR("(long trackID) -> (Track _rv)")}, |
| {"GetMovieIndTrack", (PyCFunction)MovieObj_GetMovieIndTrack, 1, |
| PyDoc_STR("(long index) -> (Track _rv)")}, |
| {"GetMovieIndTrackType", (PyCFunction)MovieObj_GetMovieIndTrackType, 1, |
| PyDoc_STR("(long index, OSType trackType, long flags) -> (Track _rv)")}, |
| {"NewMovieTrack", (PyCFunction)MovieObj_NewMovieTrack, 1, |
| PyDoc_STR("(Fixed width, Fixed height, short trackVolume) -> (Track _rv)")}, |
| {"SetAutoTrackAlternatesEnabled", (PyCFunction)MovieObj_SetAutoTrackAlternatesEnabled, 1, |
| PyDoc_STR("(Boolean enable) -> None")}, |
| {"SelectMovieAlternates", (PyCFunction)MovieObj_SelectMovieAlternates, 1, |
| PyDoc_STR("() -> None")}, |
| {"InsertMovieSegment", (PyCFunction)MovieObj_InsertMovieSegment, 1, |
| PyDoc_STR("(Movie dstMovie, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None")}, |
| {"InsertEmptyMovieSegment", (PyCFunction)MovieObj_InsertEmptyMovieSegment, 1, |
| PyDoc_STR("(TimeValue dstIn, TimeValue dstDuration) -> None")}, |
| {"DeleteMovieSegment", (PyCFunction)MovieObj_DeleteMovieSegment, 1, |
| PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")}, |
| {"ScaleMovieSegment", (PyCFunction)MovieObj_ScaleMovieSegment, 1, |
| PyDoc_STR("(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None")}, |
| {"CutMovieSelection", (PyCFunction)MovieObj_CutMovieSelection, 1, |
| PyDoc_STR("() -> (Movie _rv)")}, |
| {"CopyMovieSelection", (PyCFunction)MovieObj_CopyMovieSelection, 1, |
| PyDoc_STR("() -> (Movie _rv)")}, |
| {"PasteMovieSelection", (PyCFunction)MovieObj_PasteMovieSelection, 1, |
| PyDoc_STR("(Movie src) -> None")}, |
| {"AddMovieSelection", (PyCFunction)MovieObj_AddMovieSelection, 1, |
| PyDoc_STR("(Movie src) -> None")}, |
| {"ClearMovieSelection", (PyCFunction)MovieObj_ClearMovieSelection, 1, |
| PyDoc_STR("() -> None")}, |
| {"PutMovieIntoTypedHandle", (PyCFunction)MovieObj_PutMovieIntoTypedHandle, 1, |
| PyDoc_STR("(Track targetTrack, OSType handleType, Handle publicMovie, TimeValue start, TimeValue dur, long flags, ComponentInstance userComp) -> None")}, |
| {"CopyMovieSettings", (PyCFunction)MovieObj_CopyMovieSettings, 1, |
| PyDoc_STR("(Movie dstMovie) -> None")}, |
| {"ConvertMovieToFile", (PyCFunction)MovieObj_ConvertMovieToFile, 1, |
| PyDoc_STR("(Track onlyTrack, FSSpec outputFile, OSType fileType, OSType creator, ScriptCode scriptTag, long flags, ComponentInstance userComp) -> (short resID)")}, |
| {"GetMovieDataSize", (PyCFunction)MovieObj_GetMovieDataSize, 1, |
| PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")}, |
| {"GetMovieDataSize64", (PyCFunction)MovieObj_GetMovieDataSize64, 1, |
| PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")}, |
| {"PtInMovie", (PyCFunction)MovieObj_PtInMovie, 1, |
| PyDoc_STR("(Point pt) -> (Boolean _rv)")}, |
| {"SetMovieLanguage", (PyCFunction)MovieObj_SetMovieLanguage, 1, |
| PyDoc_STR("(long language) -> None")}, |
| {"GetMovieNextInterestingTime", (PyCFunction)MovieObj_GetMovieNextInterestingTime, 1, |
| PyDoc_STR("(short interestingTimeFlags, short numMediaTypes, OSType whichMediaTypes, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")}, |
| {"AddMovieResource", (PyCFunction)MovieObj_AddMovieResource, 1, |
| PyDoc_STR("(short resRefNum, Str255 resName) -> (short resId)")}, |
| {"UpdateMovieResource", (PyCFunction)MovieObj_UpdateMovieResource, 1, |
| PyDoc_STR("(short resRefNum, short resId, Str255 resName) -> None")}, |
| {"HasMovieChanged", (PyCFunction)MovieObj_HasMovieChanged, 1, |
| PyDoc_STR("() -> (Boolean _rv)")}, |
| {"ClearMovieChanged", (PyCFunction)MovieObj_ClearMovieChanged, 1, |
| PyDoc_STR("() -> None")}, |
| {"SetMovieDefaultDataRef", (PyCFunction)MovieObj_SetMovieDefaultDataRef, 1, |
| PyDoc_STR("(Handle dataRef, OSType dataRefType) -> None")}, |
| {"GetMovieDefaultDataRef", (PyCFunction)MovieObj_GetMovieDefaultDataRef, 1, |
| PyDoc_STR("() -> (Handle dataRef, OSType dataRefType)")}, |
| {"SetMovieColorTable", (PyCFunction)MovieObj_SetMovieColorTable, 1, |
| PyDoc_STR("(CTabHandle ctab) -> None")}, |
| {"GetMovieColorTable", (PyCFunction)MovieObj_GetMovieColorTable, 1, |
| PyDoc_STR("() -> (CTabHandle ctab)")}, |
| {"FlattenMovie", (PyCFunction)MovieObj_FlattenMovie, 1, |
| PyDoc_STR("(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Str255 resName) -> (short resId)")}, |
| {"FlattenMovieData", (PyCFunction)MovieObj_FlattenMovieData, 1, |
| PyDoc_STR("(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)")}, |
| {"MovieSearchText", (PyCFunction)MovieObj_MovieSearchText, 1, |
| PyDoc_STR("(Ptr text, long size, long searchFlags) -> (Track searchTrack, TimeValue searchTime, long searchOffset)")}, |
| {"GetPosterBox", (PyCFunction)MovieObj_GetPosterBox, 1, |
| PyDoc_STR("() -> (Rect boxRect)")}, |
| {"SetPosterBox", (PyCFunction)MovieObj_SetPosterBox, 1, |
| PyDoc_STR("(Rect boxRect) -> None")}, |
| {"GetMovieSegmentDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieSegmentDisplayBoundsRgn, 1, |
| PyDoc_STR("(TimeValue time, TimeValue duration) -> (RgnHandle _rv)")}, |
| {"GetMovieStatus", (PyCFunction)MovieObj_GetMovieStatus, 1, |
| PyDoc_STR("() -> (ComponentResult _rv, Track firstProblemTrack)")}, |
| {"NewMovieController", (PyCFunction)MovieObj_NewMovieController, 1, |
| PyDoc_STR("(Rect movieRect, long someFlags) -> (MovieController _rv)")}, |
| {"PutMovieOnScrap", (PyCFunction)MovieObj_PutMovieOnScrap, 1, |
| PyDoc_STR("(long movieScrapFlags) -> None")}, |
| {"SetMoviePlayHints", (PyCFunction)MovieObj_SetMoviePlayHints, 1, |
| PyDoc_STR("(long flags, long flagsMask) -> None")}, |
| {"GetMaxLoadedTimeInMovie", (PyCFunction)MovieObj_GetMaxLoadedTimeInMovie, 1, |
| PyDoc_STR("() -> (TimeValue time)")}, |
| {"QTMovieNeedsTimeTable", (PyCFunction)MovieObj_QTMovieNeedsTimeTable, 1, |
| PyDoc_STR("() -> (Boolean needsTimeTable)")}, |
| {"QTGetDataRefMaxFileOffset", (PyCFunction)MovieObj_QTGetDataRefMaxFileOffset, 1, |
| PyDoc_STR("(OSType dataRefType, Handle dataRef) -> (long offset)")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define MovieObj_getsetlist NULL |
| |
| |
| #define MovieObj_compare NULL |
| |
| #define MovieObj_repr NULL |
| |
| #define MovieObj_hash NULL |
| #define MovieObj_tp_init 0 |
| |
| #define MovieObj_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *MovieObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) |
| { |
| PyObject *self; |
| Movie itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, MovieObj_Convert, &itself)) return NULL; |
| if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((MovieObject *)self)->ob_itself = itself; |
| return self; |
| } |
| |
| #define MovieObj_tp_free PyObject_Del |
| |
| |
| PyTypeObject Movie_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_Qt.Movie", /*tp_name*/ |
| sizeof(MovieObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) MovieObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*tp_setattr*/ |
| (cmpfunc) MovieObj_compare, /*tp_compare*/ |
| (reprfunc) MovieObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) MovieObj_hash, /*tp_hash*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| MovieObj_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| MovieObj_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| MovieObj_tp_init, /* tp_init */ |
| MovieObj_tp_alloc, /* tp_alloc */ |
| MovieObj_tp_new, /* tp_new */ |
| MovieObj_tp_free, /* tp_free */ |
| }; |
| |
| /* --------------------- End object type Movie ---------------------- */ |
| |
| |
| static PyObject *Qt_EnterMovies(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| #ifndef EnterMovies |
| PyMac_PRECHECK(EnterMovies); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = EnterMovies(); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_ExitMovies(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef ExitMovies |
| PyMac_PRECHECK(ExitMovies); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| ExitMovies(); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_GetMoviesError(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| #ifndef GetMoviesError |
| PyMac_PRECHECK(GetMoviesError); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetMoviesError(); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_ClearMoviesStickyError(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| #ifndef ClearMoviesStickyError |
| PyMac_PRECHECK(ClearMoviesStickyError); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| ClearMoviesStickyError(); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_GetMoviesStickyError(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| #ifndef GetMoviesStickyError |
| PyMac_PRECHECK(GetMoviesStickyError); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetMoviesStickyError(); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_DisposeMatte(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| PixMapHandle theMatte; |
| #ifndef DisposeMatte |
| PyMac_PRECHECK(DisposeMatte); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &theMatte)) |
| return NULL; |
| DisposeMatte(theMatte); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_NewMovie(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| long flags; |
| #ifndef NewMovie |
| PyMac_PRECHECK(NewMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &flags)) |
| return NULL; |
| _rv = NewMovie(flags); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_GetDataHandler(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Component _rv; |
| Handle dataRef; |
| OSType dataHandlerSubType; |
| long flags; |
| #ifndef GetDataHandler |
| PyMac_PRECHECK(GetDataHandler); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&l", |
| ResObj_Convert, &dataRef, |
| PyMac_GetOSType, &dataHandlerSubType, |
| &flags)) |
| return NULL; |
| _rv = GetDataHandler(dataRef, |
| dataHandlerSubType, |
| flags); |
| _res = Py_BuildValue("O&", |
| CmpObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_PasteHandleIntoMovie(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle h; |
| OSType handleType; |
| Movie theMovie; |
| long flags; |
| ComponentInstance userComp; |
| #ifndef PasteHandleIntoMovie |
| PyMac_PRECHECK(PasteHandleIntoMovie); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&lO&", |
| ResObj_Convert, &h, |
| PyMac_GetOSType, &handleType, |
| MovieObj_Convert, &theMovie, |
| &flags, |
| CmpInstObj_Convert, &userComp)) |
| return NULL; |
| _err = PasteHandleIntoMovie(h, |
| handleType, |
| theMovie, |
| flags, |
| userComp); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_GetMovieImporterForDataRef(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| OSType dataRefType; |
| Handle dataRef; |
| long flags; |
| Component importer; |
| #ifndef GetMovieImporterForDataRef |
| PyMac_PRECHECK(GetMovieImporterForDataRef); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&l", |
| PyMac_GetOSType, &dataRefType, |
| ResObj_Convert, &dataRef, |
| &flags)) |
| return NULL; |
| _err = GetMovieImporterForDataRef(dataRefType, |
| dataRef, |
| flags, |
| &importer); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| CmpObj_New, importer); |
| return _res; |
| } |
| |
| static PyObject *Qt_QTGetMIMETypeInfo(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| char* mimeStringStart; |
| short mimeStringLength; |
| OSType infoSelector; |
| void * infoDataPtr; |
| long infoDataSize; |
| #ifndef QTGetMIMETypeInfo |
| PyMac_PRECHECK(QTGetMIMETypeInfo); |
| #endif |
| if (!PyArg_ParseTuple(_args, "shO&s", |
| &mimeStringStart, |
| &mimeStringLength, |
| PyMac_GetOSType, &infoSelector, |
| &infoDataPtr)) |
| return NULL; |
| _err = QTGetMIMETypeInfo(mimeStringStart, |
| mimeStringLength, |
| infoSelector, |
| infoDataPtr, |
| &infoDataSize); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| infoDataSize); |
| return _res; |
| } |
| |
| static PyObject *Qt_TrackTimeToMediaTime(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| TimeValue value; |
| Track theTrack; |
| #ifndef TrackTimeToMediaTime |
| PyMac_PRECHECK(TrackTimeToMediaTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lO&", |
| &value, |
| TrackObj_Convert, &theTrack)) |
| return NULL; |
| _rv = TrackTimeToMediaTime(value, |
| theTrack); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_NewUserData(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| UserData theUserData; |
| #ifndef NewUserData |
| PyMac_PRECHECK(NewUserData); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = NewUserData(&theUserData); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| UserDataObj_New, theUserData); |
| return _res; |
| } |
| |
| static PyObject *Qt_NewUserDataFromHandle(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle h; |
| UserData theUserData; |
| #ifndef NewUserDataFromHandle |
| PyMac_PRECHECK(NewUserDataFromHandle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &h)) |
| return NULL; |
| _err = NewUserDataFromHandle(h, |
| &theUserData); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| UserDataObj_New, theUserData); |
| return _res; |
| } |
| |
| static PyObject *Qt_CreateMovieFile(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| FSSpec fileSpec; |
| OSType creator; |
| ScriptCode scriptTag; |
| long createMovieFileFlags; |
| short resRefNum; |
| Movie newmovie; |
| #ifndef CreateMovieFile |
| PyMac_PRECHECK(CreateMovieFile); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&hl", |
| PyMac_GetFSSpec, &fileSpec, |
| PyMac_GetOSType, &creator, |
| &scriptTag, |
| &createMovieFileFlags)) |
| return NULL; |
| _err = CreateMovieFile(&fileSpec, |
| creator, |
| scriptTag, |
| createMovieFileFlags, |
| &resRefNum, |
| &newmovie); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("hO&", |
| resRefNum, |
| MovieObj_New, newmovie); |
| return _res; |
| } |
| |
| static PyObject *Qt_OpenMovieFile(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| FSSpec fileSpec; |
| short resRefNum; |
| SInt8 permission; |
| #ifndef OpenMovieFile |
| PyMac_PRECHECK(OpenMovieFile); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&b", |
| PyMac_GetFSSpec, &fileSpec, |
| &permission)) |
| return NULL; |
| _err = OpenMovieFile(&fileSpec, |
| &resRefNum, |
| permission); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| resRefNum); |
| return _res; |
| } |
| |
| static PyObject *Qt_CloseMovieFile(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short resRefNum; |
| #ifndef CloseMovieFile |
| PyMac_PRECHECK(CloseMovieFile); |
| #endif |
| if (!PyArg_ParseTuple(_args, "h", |
| &resRefNum)) |
| return NULL; |
| _err = CloseMovieFile(resRefNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_DeleteMovieFile(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| FSSpec fileSpec; |
| #ifndef DeleteMovieFile |
| PyMac_PRECHECK(DeleteMovieFile); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetFSSpec, &fileSpec)) |
| return NULL; |
| _err = DeleteMovieFile(&fileSpec); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_NewMovieFromFile(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie theMovie; |
| short resRefNum; |
| short resId; |
| short newMovieFlags; |
| Boolean dataRefWasChanged; |
| #ifndef NewMovieFromFile |
| PyMac_PRECHECK(NewMovieFromFile); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hhh", |
| &resRefNum, |
| &resId, |
| &newMovieFlags)) |
| return NULL; |
| _err = NewMovieFromFile(&theMovie, |
| resRefNum, |
| &resId, |
| (StringPtr)0, |
| newMovieFlags, |
| &dataRefWasChanged); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&hb", |
| MovieObj_New, theMovie, |
| resId, |
| dataRefWasChanged); |
| return _res; |
| } |
| |
| static PyObject *Qt_NewMovieFromHandle(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie theMovie; |
| Handle h; |
| short newMovieFlags; |
| Boolean dataRefWasChanged; |
| #ifndef NewMovieFromHandle |
| PyMac_PRECHECK(NewMovieFromHandle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&h", |
| ResObj_Convert, &h, |
| &newMovieFlags)) |
| return NULL; |
| _err = NewMovieFromHandle(&theMovie, |
| h, |
| newMovieFlags, |
| &dataRefWasChanged); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&b", |
| MovieObj_New, theMovie, |
| dataRefWasChanged); |
| return _res; |
| } |
| |
| static PyObject *Qt_NewMovieFromDataFork(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie theMovie; |
| short fRefNum; |
| long fileOffset; |
| short newMovieFlags; |
| Boolean dataRefWasChanged; |
| #ifndef NewMovieFromDataFork |
| PyMac_PRECHECK(NewMovieFromDataFork); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hlh", |
| &fRefNum, |
| &fileOffset, |
| &newMovieFlags)) |
| return NULL; |
| _err = NewMovieFromDataFork(&theMovie, |
| fRefNum, |
| fileOffset, |
| newMovieFlags, |
| &dataRefWasChanged); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&b", |
| MovieObj_New, theMovie, |
| dataRefWasChanged); |
| return _res; |
| } |
| |
| static PyObject *Qt_NewMovieFromDataFork64(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie theMovie; |
| long fRefNum; |
| wide fileOffset; |
| short newMovieFlags; |
| Boolean dataRefWasChanged; |
| #ifndef NewMovieFromDataFork64 |
| PyMac_PRECHECK(NewMovieFromDataFork64); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lO&h", |
| &fRefNum, |
| PyMac_Getwide, &fileOffset, |
| &newMovieFlags)) |
| return NULL; |
| _err = NewMovieFromDataFork64(&theMovie, |
| fRefNum, |
| &fileOffset, |
| newMovieFlags, |
| &dataRefWasChanged); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&b", |
| MovieObj_New, theMovie, |
| dataRefWasChanged); |
| return _res; |
| } |
| |
| static PyObject *Qt_NewMovieFromDataRef(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie m; |
| short flags; |
| short id; |
| Handle dataRef; |
| OSType dataRefType; |
| #ifndef NewMovieFromDataRef |
| PyMac_PRECHECK(NewMovieFromDataRef); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hO&O&", |
| &flags, |
| ResObj_Convert, &dataRef, |
| PyMac_GetOSType, &dataRefType)) |
| return NULL; |
| _err = NewMovieFromDataRef(&m, |
| flags, |
| &id, |
| dataRef, |
| dataRefType); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&h", |
| MovieObj_New, m, |
| id); |
| return _res; |
| } |
| |
| static PyObject *Qt_RemoveMovieResource(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short resRefNum; |
| short resId; |
| #ifndef RemoveMovieResource |
| PyMac_PRECHECK(RemoveMovieResource); |
| #endif |
| if (!PyArg_ParseTuple(_args, "hh", |
| &resRefNum, |
| &resId)) |
| return NULL; |
| _err = RemoveMovieResource(resRefNum, |
| resId); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_CreateShortcutMovieFile(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| FSSpec fileSpec; |
| OSType creator; |
| ScriptCode scriptTag; |
| long createMovieFileFlags; |
| Handle targetDataRef; |
| OSType targetDataRefType; |
| #ifndef CreateShortcutMovieFile |
| PyMac_PRECHECK(CreateShortcutMovieFile); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&hlO&O&", |
| PyMac_GetFSSpec, &fileSpec, |
| PyMac_GetOSType, &creator, |
| &scriptTag, |
| &createMovieFileFlags, |
| ResObj_Convert, &targetDataRef, |
| PyMac_GetOSType, &targetDataRefType)) |
| return NULL; |
| _err = CreateShortcutMovieFile(&fileSpec, |
| creator, |
| scriptTag, |
| createMovieFileFlags, |
| targetDataRef, |
| targetDataRefType); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_CanQuickTimeOpenFile(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| FSSpec fileSpec; |
| OSType fileType; |
| OSType fileNameExtension; |
| Boolean outCanOpenWithGraphicsImporter; |
| Boolean outCanOpenAsMovie; |
| Boolean outPreferGraphicsImporter; |
| UInt32 inFlags; |
| #ifndef CanQuickTimeOpenFile |
| PyMac_PRECHECK(CanQuickTimeOpenFile); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&l", |
| PyMac_GetFSSpec, &fileSpec, |
| PyMac_GetOSType, &fileType, |
| PyMac_GetOSType, &fileNameExtension, |
| &inFlags)) |
| return NULL; |
| _err = CanQuickTimeOpenFile(&fileSpec, |
| fileType, |
| fileNameExtension, |
| &outCanOpenWithGraphicsImporter, |
| &outCanOpenAsMovie, |
| &outPreferGraphicsImporter, |
| inFlags); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("bbb", |
| outCanOpenWithGraphicsImporter, |
| outCanOpenAsMovie, |
| outPreferGraphicsImporter); |
| return _res; |
| } |
| |
| static PyObject *Qt_CanQuickTimeOpenDataRef(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle dataRef; |
| OSType dataRefType; |
| Boolean outCanOpenWithGraphicsImporter; |
| Boolean outCanOpenAsMovie; |
| Boolean outPreferGraphicsImporter; |
| UInt32 inFlags; |
| #ifndef CanQuickTimeOpenDataRef |
| PyMac_PRECHECK(CanQuickTimeOpenDataRef); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&l", |
| ResObj_Convert, &dataRef, |
| PyMac_GetOSType, &dataRefType, |
| &inFlags)) |
| return NULL; |
| _err = CanQuickTimeOpenDataRef(dataRef, |
| dataRefType, |
| &outCanOpenWithGraphicsImporter, |
| &outCanOpenAsMovie, |
| &outPreferGraphicsImporter, |
| inFlags); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("bbb", |
| outCanOpenWithGraphicsImporter, |
| outCanOpenAsMovie, |
| outPreferGraphicsImporter); |
| return _res; |
| } |
| |
| static PyObject *Qt_NewMovieFromScrap(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| long newMovieFlags; |
| #ifndef NewMovieFromScrap |
| PyMac_PRECHECK(NewMovieFromScrap); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &newMovieFlags)) |
| return NULL; |
| _rv = NewMovieFromScrap(newMovieFlags); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_QTNewAlias(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| FSSpec fss; |
| AliasHandle alias; |
| Boolean minimal; |
| #ifndef QTNewAlias |
| PyMac_PRECHECK(QTNewAlias); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&b", |
| PyMac_GetFSSpec, &fss, |
| &minimal)) |
| return NULL; |
| _err = QTNewAlias(&fss, |
| &alias, |
| minimal); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| ResObj_New, alias); |
| return _res; |
| } |
| |
| static PyObject *Qt_EndFullScreen(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Ptr fullState; |
| long flags; |
| #ifndef EndFullScreen |
| PyMac_PRECHECK(EndFullScreen); |
| #endif |
| if (!PyArg_ParseTuple(_args, "sl", |
| &fullState, |
| &flags)) |
| return NULL; |
| _err = EndFullScreen(fullState, |
| flags); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_AddSoundDescriptionExtension(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SoundDescriptionHandle desc; |
| Handle extension; |
| OSType idType; |
| #ifndef AddSoundDescriptionExtension |
| PyMac_PRECHECK(AddSoundDescriptionExtension); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&", |
| ResObj_Convert, &desc, |
| ResObj_Convert, &extension, |
| PyMac_GetOSType, &idType)) |
| return NULL; |
| _err = AddSoundDescriptionExtension(desc, |
| extension, |
| idType); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_GetSoundDescriptionExtension(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SoundDescriptionHandle desc; |
| Handle extension; |
| OSType idType; |
| #ifndef GetSoundDescriptionExtension |
| PyMac_PRECHECK(GetSoundDescriptionExtension); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| ResObj_Convert, &desc, |
| PyMac_GetOSType, &idType)) |
| return NULL; |
| _err = GetSoundDescriptionExtension(desc, |
| &extension, |
| idType); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| ResObj_New, extension); |
| return _res; |
| } |
| |
| static PyObject *Qt_RemoveSoundDescriptionExtension(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SoundDescriptionHandle desc; |
| OSType idType; |
| #ifndef RemoveSoundDescriptionExtension |
| PyMac_PRECHECK(RemoveSoundDescriptionExtension); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| ResObj_Convert, &desc, |
| PyMac_GetOSType, &idType)) |
| return NULL; |
| _err = RemoveSoundDescriptionExtension(desc, |
| idType); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_QTIsStandardParameterDialogEvent(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| EventRecord pEvent; |
| QTParameterDialog createdDialog; |
| #ifndef QTIsStandardParameterDialogEvent |
| PyMac_PRECHECK(QTIsStandardParameterDialogEvent); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &createdDialog)) |
| return NULL; |
| _err = QTIsStandardParameterDialogEvent(&pEvent, |
| createdDialog); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildEventRecord, &pEvent); |
| return _res; |
| } |
| |
| static PyObject *Qt_QTDismissStandardParameterDialog(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| QTParameterDialog createdDialog; |
| #ifndef QTDismissStandardParameterDialog |
| PyMac_PRECHECK(QTDismissStandardParameterDialog); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &createdDialog)) |
| return NULL; |
| _err = QTDismissStandardParameterDialog(createdDialog); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_QTStandardParameterDialogDoAction(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| QTParameterDialog createdDialog; |
| long action; |
| void * params; |
| #ifndef QTStandardParameterDialogDoAction |
| PyMac_PRECHECK(QTStandardParameterDialogDoAction); |
| #endif |
| if (!PyArg_ParseTuple(_args, "lls", |
| &createdDialog, |
| &action, |
| ¶ms)) |
| return NULL; |
| _err = QTStandardParameterDialogDoAction(createdDialog, |
| action, |
| params); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_QTRegisterAccessKey(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Str255 accessKeyType; |
| long flags; |
| Handle accessKey; |
| #ifndef QTRegisterAccessKey |
| PyMac_PRECHECK(QTRegisterAccessKey); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&lO&", |
| PyMac_GetStr255, accessKeyType, |
| &flags, |
| ResObj_Convert, &accessKey)) |
| return NULL; |
| _err = QTRegisterAccessKey(accessKeyType, |
| flags, |
| accessKey); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_QTUnregisterAccessKey(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Str255 accessKeyType; |
| long flags; |
| Handle accessKey; |
| #ifndef QTUnregisterAccessKey |
| PyMac_PRECHECK(QTUnregisterAccessKey); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&lO&", |
| PyMac_GetStr255, accessKeyType, |
| &flags, |
| ResObj_Convert, &accessKey)) |
| return NULL; |
| _err = QTUnregisterAccessKey(accessKeyType, |
| flags, |
| accessKey); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_QTTextToNativeText(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle theText; |
| long encoding; |
| long flags; |
| #ifndef QTTextToNativeText |
| PyMac_PRECHECK(QTTextToNativeText); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&ll", |
| ResObj_Convert, &theText, |
| &encoding, |
| &flags)) |
| return NULL; |
| _err = QTTextToNativeText(theText, |
| encoding, |
| flags); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_VideoMediaResetStatistics(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| #ifndef VideoMediaResetStatistics |
| PyMac_PRECHECK(VideoMediaResetStatistics); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpInstObj_Convert, &mh)) |
| return NULL; |
| _rv = VideoMediaResetStatistics(mh); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_VideoMediaGetStatistics(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| #ifndef VideoMediaGetStatistics |
| PyMac_PRECHECK(VideoMediaGetStatistics); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpInstObj_Convert, &mh)) |
| return NULL; |
| _rv = VideoMediaGetStatistics(mh); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_VideoMediaGetStallCount(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| unsigned long stalls; |
| #ifndef VideoMediaGetStallCount |
| PyMac_PRECHECK(VideoMediaGetStallCount); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpInstObj_Convert, &mh)) |
| return NULL; |
| _rv = VideoMediaGetStallCount(mh, |
| &stalls); |
| _res = Py_BuildValue("ll", |
| _rv, |
| stalls); |
| return _res; |
| } |
| |
| static PyObject *Qt_VideoMediaSetCodecParameter(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| CodecType cType; |
| OSType parameterID; |
| long parameterChangeSeed; |
| void * dataPtr; |
| long dataSize; |
| #ifndef VideoMediaSetCodecParameter |
| PyMac_PRECHECK(VideoMediaSetCodecParameter); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&lsl", |
| CmpInstObj_Convert, &mh, |
| PyMac_GetOSType, &cType, |
| PyMac_GetOSType, ¶meterID, |
| ¶meterChangeSeed, |
| &dataPtr, |
| &dataSize)) |
| return NULL; |
| _rv = VideoMediaSetCodecParameter(mh, |
| cType, |
| parameterID, |
| parameterChangeSeed, |
| dataPtr, |
| dataSize); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_VideoMediaGetCodecParameter(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| CodecType cType; |
| OSType parameterID; |
| Handle outParameterData; |
| #ifndef VideoMediaGetCodecParameter |
| PyMac_PRECHECK(VideoMediaGetCodecParameter); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&O&", |
| CmpInstObj_Convert, &mh, |
| PyMac_GetOSType, &cType, |
| PyMac_GetOSType, ¶meterID, |
| ResObj_Convert, &outParameterData)) |
| return NULL; |
| _rv = VideoMediaGetCodecParameter(mh, |
| cType, |
| parameterID, |
| outParameterData); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_TextMediaAddTextSample(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| Ptr text; |
| unsigned long size; |
| short fontNumber; |
| short fontSize; |
| Style textFace; |
| RGBColor textColor; |
| RGBColor backColor; |
| short textJustification; |
| Rect textBox; |
| long displayFlags; |
| TimeValue scrollDelay; |
| short hiliteStart; |
| short hiliteEnd; |
| RGBColor rgbHiliteColor; |
| TimeValue duration; |
| TimeValue sampleTime; |
| #ifndef TextMediaAddTextSample |
| PyMac_PRECHECK(TextMediaAddTextSample); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&slhhbhllhhl", |
| CmpInstObj_Convert, &mh, |
| &text, |
| &size, |
| &fontNumber, |
| &fontSize, |
| &textFace, |
| &textJustification, |
| &displayFlags, |
| &scrollDelay, |
| &hiliteStart, |
| &hiliteEnd, |
| &duration)) |
| return NULL; |
| _rv = TextMediaAddTextSample(mh, |
| text, |
| size, |
| fontNumber, |
| fontSize, |
| textFace, |
| &textColor, |
| &backColor, |
| textJustification, |
| &textBox, |
| displayFlags, |
| scrollDelay, |
| hiliteStart, |
| hiliteEnd, |
| &rgbHiliteColor, |
| duration, |
| &sampleTime); |
| _res = Py_BuildValue("lO&O&O&O&l", |
| _rv, |
| QdRGB_New, &textColor, |
| QdRGB_New, &backColor, |
| PyMac_BuildRect, &textBox, |
| QdRGB_New, &rgbHiliteColor, |
| sampleTime); |
| return _res; |
| } |
| |
| static PyObject *Qt_TextMediaAddTESample(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| TEHandle hTE; |
| RGBColor backColor; |
| short textJustification; |
| Rect textBox; |
| long displayFlags; |
| TimeValue scrollDelay; |
| short hiliteStart; |
| short hiliteEnd; |
| RGBColor rgbHiliteColor; |
| TimeValue duration; |
| TimeValue sampleTime; |
| #ifndef TextMediaAddTESample |
| PyMac_PRECHECK(TextMediaAddTESample); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&hllhhl", |
| CmpInstObj_Convert, &mh, |
| ResObj_Convert, &hTE, |
| &textJustification, |
| &displayFlags, |
| &scrollDelay, |
| &hiliteStart, |
| &hiliteEnd, |
| &duration)) |
| return NULL; |
| _rv = TextMediaAddTESample(mh, |
| hTE, |
| &backColor, |
| textJustification, |
| &textBox, |
| displayFlags, |
| scrollDelay, |
| hiliteStart, |
| hiliteEnd, |
| &rgbHiliteColor, |
| duration, |
| &sampleTime); |
| _res = Py_BuildValue("lO&O&O&l", |
| _rv, |
| QdRGB_New, &backColor, |
| PyMac_BuildRect, &textBox, |
| QdRGB_New, &rgbHiliteColor, |
| sampleTime); |
| return _res; |
| } |
| |
| static PyObject *Qt_TextMediaAddHiliteSample(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short hiliteStart; |
| short hiliteEnd; |
| RGBColor rgbHiliteColor; |
| TimeValue duration; |
| TimeValue sampleTime; |
| #ifndef TextMediaAddHiliteSample |
| PyMac_PRECHECK(TextMediaAddHiliteSample); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&hhl", |
| CmpInstObj_Convert, &mh, |
| &hiliteStart, |
| &hiliteEnd, |
| &duration)) |
| return NULL; |
| _rv = TextMediaAddHiliteSample(mh, |
| hiliteStart, |
| hiliteEnd, |
| &rgbHiliteColor, |
| duration, |
| &sampleTime); |
| _res = Py_BuildValue("lO&l", |
| _rv, |
| QdRGB_New, &rgbHiliteColor, |
| sampleTime); |
| return _res; |
| } |
| |
| static PyObject *Qt_TextMediaDrawRaw(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| GWorldPtr gw; |
| GDHandle gd; |
| void * data; |
| long dataSize; |
| TextDescriptionHandle tdh; |
| #ifndef TextMediaDrawRaw |
| PyMac_PRECHECK(TextMediaDrawRaw); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&slO&", |
| CmpInstObj_Convert, &mh, |
| GWorldObj_Convert, &gw, |
| OptResObj_Convert, &gd, |
| &data, |
| &dataSize, |
| ResObj_Convert, &tdh)) |
| return NULL; |
| _rv = TextMediaDrawRaw(mh, |
| gw, |
| gd, |
| data, |
| dataSize, |
| tdh); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_TextMediaSetTextProperty(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| TimeValue atMediaTime; |
| long propertyType; |
| void * data; |
| long dataSize; |
| #ifndef TextMediaSetTextProperty |
| PyMac_PRECHECK(TextMediaSetTextProperty); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&llsl", |
| CmpInstObj_Convert, &mh, |
| &atMediaTime, |
| &propertyType, |
| &data, |
| &dataSize)) |
| return NULL; |
| _rv = TextMediaSetTextProperty(mh, |
| atMediaTime, |
| propertyType, |
| data, |
| dataSize); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_TextMediaRawSetup(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| GWorldPtr gw; |
| GDHandle gd; |
| void * data; |
| long dataSize; |
| TextDescriptionHandle tdh; |
| TimeValue sampleDuration; |
| #ifndef TextMediaRawSetup |
| PyMac_PRECHECK(TextMediaRawSetup); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&slO&l", |
| CmpInstObj_Convert, &mh, |
| GWorldObj_Convert, &gw, |
| OptResObj_Convert, &gd, |
| &data, |
| &dataSize, |
| ResObj_Convert, &tdh, |
| &sampleDuration)) |
| return NULL; |
| _rv = TextMediaRawSetup(mh, |
| gw, |
| gd, |
| data, |
| dataSize, |
| tdh, |
| sampleDuration); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_TextMediaRawIdle(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| GWorldPtr gw; |
| GDHandle gd; |
| TimeValue sampleTime; |
| long flagsIn; |
| long flagsOut; |
| #ifndef TextMediaRawIdle |
| PyMac_PRECHECK(TextMediaRawIdle); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&ll", |
| CmpInstObj_Convert, &mh, |
| GWorldObj_Convert, &gw, |
| OptResObj_Convert, &gd, |
| &sampleTime, |
| &flagsIn)) |
| return NULL; |
| _rv = TextMediaRawIdle(mh, |
| gw, |
| gd, |
| sampleTime, |
| flagsIn, |
| &flagsOut); |
| _res = Py_BuildValue("ll", |
| _rv, |
| flagsOut); |
| return _res; |
| } |
| |
| static PyObject *Qt_TextMediaGetTextProperty(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| TimeValue atMediaTime; |
| long propertyType; |
| void * data; |
| long dataSize; |
| #ifndef TextMediaGetTextProperty |
| PyMac_PRECHECK(TextMediaGetTextProperty); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&llsl", |
| CmpInstObj_Convert, &mh, |
| &atMediaTime, |
| &propertyType, |
| &data, |
| &dataSize)) |
| return NULL; |
| _rv = TextMediaGetTextProperty(mh, |
| atMediaTime, |
| propertyType, |
| data, |
| dataSize); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_TextMediaFindNextText(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| Ptr text; |
| long size; |
| short findFlags; |
| TimeValue startTime; |
| TimeValue foundTime; |
| TimeValue foundDuration; |
| long offset; |
| #ifndef TextMediaFindNextText |
| PyMac_PRECHECK(TextMediaFindNextText); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&slhl", |
| CmpInstObj_Convert, &mh, |
| &text, |
| &size, |
| &findFlags, |
| &startTime)) |
| return NULL; |
| _rv = TextMediaFindNextText(mh, |
| text, |
| size, |
| findFlags, |
| startTime, |
| &foundTime, |
| &foundDuration, |
| &offset); |
| _res = Py_BuildValue("llll", |
| _rv, |
| foundTime, |
| foundDuration, |
| offset); |
| return _res; |
| } |
| |
| static PyObject *Qt_TextMediaHiliteTextSample(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| TimeValue sampleTime; |
| short hiliteStart; |
| short hiliteEnd; |
| RGBColor rgbHiliteColor; |
| #ifndef TextMediaHiliteTextSample |
| PyMac_PRECHECK(TextMediaHiliteTextSample); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&lhh", |
| CmpInstObj_Convert, &mh, |
| &sampleTime, |
| &hiliteStart, |
| &hiliteEnd)) |
| return NULL; |
| _rv = TextMediaHiliteTextSample(mh, |
| sampleTime, |
| hiliteStart, |
| hiliteEnd, |
| &rgbHiliteColor); |
| _res = Py_BuildValue("lO&", |
| _rv, |
| QdRGB_New, &rgbHiliteColor); |
| return _res; |
| } |
| |
| static PyObject *Qt_TextMediaSetTextSampleData(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| void * data; |
| OSType dataType; |
| #ifndef TextMediaSetTextSampleData |
| PyMac_PRECHECK(TextMediaSetTextSampleData); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&sO&", |
| CmpInstObj_Convert, &mh, |
| &data, |
| PyMac_GetOSType, &dataType)) |
| return NULL; |
| _rv = TextMediaSetTextSampleData(mh, |
| data, |
| dataType); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaSetProperty(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short spriteIndex; |
| long propertyType; |
| void * propertyValue; |
| #ifndef SpriteMediaSetProperty |
| PyMac_PRECHECK(SpriteMediaSetProperty); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&hls", |
| CmpInstObj_Convert, &mh, |
| &spriteIndex, |
| &propertyType, |
| &propertyValue)) |
| return NULL; |
| _rv = SpriteMediaSetProperty(mh, |
| spriteIndex, |
| propertyType, |
| propertyValue); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaGetProperty(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short spriteIndex; |
| long propertyType; |
| void * propertyValue; |
| #ifndef SpriteMediaGetProperty |
| PyMac_PRECHECK(SpriteMediaGetProperty); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&hls", |
| CmpInstObj_Convert, &mh, |
| &spriteIndex, |
| &propertyType, |
| &propertyValue)) |
| return NULL; |
| _rv = SpriteMediaGetProperty(mh, |
| spriteIndex, |
| propertyType, |
| propertyValue); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaHitTestSprites(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| long flags; |
| Point loc; |
| short spriteHitIndex; |
| #ifndef SpriteMediaHitTestSprites |
| PyMac_PRECHECK(SpriteMediaHitTestSprites); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&lO&", |
| CmpInstObj_Convert, &mh, |
| &flags, |
| PyMac_GetPoint, &loc)) |
| return NULL; |
| _rv = SpriteMediaHitTestSprites(mh, |
| flags, |
| loc, |
| &spriteHitIndex); |
| _res = Py_BuildValue("lh", |
| _rv, |
| spriteHitIndex); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaCountSprites(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short numSprites; |
| #ifndef SpriteMediaCountSprites |
| PyMac_PRECHECK(SpriteMediaCountSprites); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpInstObj_Convert, &mh)) |
| return NULL; |
| _rv = SpriteMediaCountSprites(mh, |
| &numSprites); |
| _res = Py_BuildValue("lh", |
| _rv, |
| numSprites); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaCountImages(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short numImages; |
| #ifndef SpriteMediaCountImages |
| PyMac_PRECHECK(SpriteMediaCountImages); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpInstObj_Convert, &mh)) |
| return NULL; |
| _rv = SpriteMediaCountImages(mh, |
| &numImages); |
| _res = Py_BuildValue("lh", |
| _rv, |
| numImages); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaGetIndImageDescription(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short imageIndex; |
| ImageDescriptionHandle imageDescription; |
| #ifndef SpriteMediaGetIndImageDescription |
| PyMac_PRECHECK(SpriteMediaGetIndImageDescription); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&hO&", |
| CmpInstObj_Convert, &mh, |
| &imageIndex, |
| ResObj_Convert, &imageDescription)) |
| return NULL; |
| _rv = SpriteMediaGetIndImageDescription(mh, |
| imageIndex, |
| imageDescription); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaGetDisplayedSampleNumber(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| long sampleNum; |
| #ifndef SpriteMediaGetDisplayedSampleNumber |
| PyMac_PRECHECK(SpriteMediaGetDisplayedSampleNumber); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpInstObj_Convert, &mh)) |
| return NULL; |
| _rv = SpriteMediaGetDisplayedSampleNumber(mh, |
| &sampleNum); |
| _res = Py_BuildValue("ll", |
| _rv, |
| sampleNum); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaGetSpriteName(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID spriteID; |
| Str255 spriteName; |
| #ifndef SpriteMediaGetSpriteName |
| PyMac_PRECHECK(SpriteMediaGetSpriteName); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&lO&", |
| CmpInstObj_Convert, &mh, |
| &spriteID, |
| PyMac_GetStr255, spriteName)) |
| return NULL; |
| _rv = SpriteMediaGetSpriteName(mh, |
| spriteID, |
| spriteName); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaGetImageName(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short imageIndex; |
| Str255 imageName; |
| #ifndef SpriteMediaGetImageName |
| PyMac_PRECHECK(SpriteMediaGetImageName); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&hO&", |
| CmpInstObj_Convert, &mh, |
| &imageIndex, |
| PyMac_GetStr255, imageName)) |
| return NULL; |
| _rv = SpriteMediaGetImageName(mh, |
| imageIndex, |
| imageName); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaSetSpriteProperty(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID spriteID; |
| long propertyType; |
| void * propertyValue; |
| #ifndef SpriteMediaSetSpriteProperty |
| PyMac_PRECHECK(SpriteMediaSetSpriteProperty); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&lls", |
| CmpInstObj_Convert, &mh, |
| &spriteID, |
| &propertyType, |
| &propertyValue)) |
| return NULL; |
| _rv = SpriteMediaSetSpriteProperty(mh, |
| spriteID, |
| propertyType, |
| propertyValue); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaGetSpriteProperty(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID spriteID; |
| long propertyType; |
| void * propertyValue; |
| #ifndef SpriteMediaGetSpriteProperty |
| PyMac_PRECHECK(SpriteMediaGetSpriteProperty); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&lls", |
| CmpInstObj_Convert, &mh, |
| &spriteID, |
| &propertyType, |
| &propertyValue)) |
| return NULL; |
| _rv = SpriteMediaGetSpriteProperty(mh, |
| spriteID, |
| propertyType, |
| propertyValue); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaHitTestAllSprites(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| long flags; |
| Point loc; |
| QTAtomID spriteHitID; |
| #ifndef SpriteMediaHitTestAllSprites |
| PyMac_PRECHECK(SpriteMediaHitTestAllSprites); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&lO&", |
| CmpInstObj_Convert, &mh, |
| &flags, |
| PyMac_GetPoint, &loc)) |
| return NULL; |
| _rv = SpriteMediaHitTestAllSprites(mh, |
| flags, |
| loc, |
| &spriteHitID); |
| _res = Py_BuildValue("ll", |
| _rv, |
| spriteHitID); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaHitTestOneSprite(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID spriteID; |
| long flags; |
| Point loc; |
| Boolean wasHit; |
| #ifndef SpriteMediaHitTestOneSprite |
| PyMac_PRECHECK(SpriteMediaHitTestOneSprite); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&llO&", |
| CmpInstObj_Convert, &mh, |
| &spriteID, |
| &flags, |
| PyMac_GetPoint, &loc)) |
| return NULL; |
| _rv = SpriteMediaHitTestOneSprite(mh, |
| spriteID, |
| flags, |
| loc, |
| &wasHit); |
| _res = Py_BuildValue("lb", |
| _rv, |
| wasHit); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaSpriteIndexToID(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short spriteIndex; |
| QTAtomID spriteID; |
| #ifndef SpriteMediaSpriteIndexToID |
| PyMac_PRECHECK(SpriteMediaSpriteIndexToID); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&h", |
| CmpInstObj_Convert, &mh, |
| &spriteIndex)) |
| return NULL; |
| _rv = SpriteMediaSpriteIndexToID(mh, |
| spriteIndex, |
| &spriteID); |
| _res = Py_BuildValue("ll", |
| _rv, |
| spriteID); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaSpriteIDToIndex(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID spriteID; |
| short spriteIndex; |
| #ifndef SpriteMediaSpriteIDToIndex |
| PyMac_PRECHECK(SpriteMediaSpriteIDToIndex); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| CmpInstObj_Convert, &mh, |
| &spriteID)) |
| return NULL; |
| _rv = SpriteMediaSpriteIDToIndex(mh, |
| spriteID, |
| &spriteIndex); |
| _res = Py_BuildValue("lh", |
| _rv, |
| spriteIndex); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaSetActionVariable(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID variableID; |
| float value; |
| #ifndef SpriteMediaSetActionVariable |
| PyMac_PRECHECK(SpriteMediaSetActionVariable); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&lf", |
| CmpInstObj_Convert, &mh, |
| &variableID, |
| &value)) |
| return NULL; |
| _rv = SpriteMediaSetActionVariable(mh, |
| variableID, |
| &value); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaGetActionVariable(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID variableID; |
| float value; |
| #ifndef SpriteMediaGetActionVariable |
| PyMac_PRECHECK(SpriteMediaGetActionVariable); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| CmpInstObj_Convert, &mh, |
| &variableID)) |
| return NULL; |
| _rv = SpriteMediaGetActionVariable(mh, |
| variableID, |
| &value); |
| _res = Py_BuildValue("lf", |
| _rv, |
| value); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaDisposeSprite(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID spriteID; |
| #ifndef SpriteMediaDisposeSprite |
| PyMac_PRECHECK(SpriteMediaDisposeSprite); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| CmpInstObj_Convert, &mh, |
| &spriteID)) |
| return NULL; |
| _rv = SpriteMediaDisposeSprite(mh, |
| spriteID); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaSetActionVariableToString(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID variableID; |
| Ptr theCString; |
| #ifndef SpriteMediaSetActionVariableToString |
| PyMac_PRECHECK(SpriteMediaSetActionVariableToString); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&ls", |
| CmpInstObj_Convert, &mh, |
| &variableID, |
| &theCString)) |
| return NULL; |
| _rv = SpriteMediaSetActionVariableToString(mh, |
| variableID, |
| theCString); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_SpriteMediaGetActionVariableAsString(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID variableID; |
| Handle theCString; |
| #ifndef SpriteMediaGetActionVariableAsString |
| PyMac_PRECHECK(SpriteMediaGetActionVariableAsString); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| CmpInstObj_Convert, &mh, |
| &variableID)) |
| return NULL; |
| _rv = SpriteMediaGetActionVariableAsString(mh, |
| variableID, |
| &theCString); |
| _res = Py_BuildValue("lO&", |
| _rv, |
| ResObj_New, theCString); |
| return _res; |
| } |
| |
| static PyObject *Qt_FlashMediaSetPan(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short xPercent; |
| short yPercent; |
| #ifndef FlashMediaSetPan |
| PyMac_PRECHECK(FlashMediaSetPan); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&hh", |
| CmpInstObj_Convert, &mh, |
| &xPercent, |
| &yPercent)) |
| return NULL; |
| _rv = FlashMediaSetPan(mh, |
| xPercent, |
| yPercent); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_FlashMediaSetZoom(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short factor; |
| #ifndef FlashMediaSetZoom |
| PyMac_PRECHECK(FlashMediaSetZoom); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&h", |
| CmpInstObj_Convert, &mh, |
| &factor)) |
| return NULL; |
| _rv = FlashMediaSetZoom(mh, |
| factor); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_FlashMediaSetZoomRect(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| long left; |
| long top; |
| long right; |
| long bottom; |
| #ifndef FlashMediaSetZoomRect |
| PyMac_PRECHECK(FlashMediaSetZoomRect); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&llll", |
| CmpInstObj_Convert, &mh, |
| &left, |
| &top, |
| &right, |
| &bottom)) |
| return NULL; |
| _rv = FlashMediaSetZoomRect(mh, |
| left, |
| top, |
| right, |
| bottom); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_FlashMediaGetRefConBounds(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| long refCon; |
| long left; |
| long top; |
| long right; |
| long bottom; |
| #ifndef FlashMediaGetRefConBounds |
| PyMac_PRECHECK(FlashMediaGetRefConBounds); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| CmpInstObj_Convert, &mh, |
| &refCon)) |
| return NULL; |
| _rv = FlashMediaGetRefConBounds(mh, |
| refCon, |
| &left, |
| &top, |
| &right, |
| &bottom); |
| _res = Py_BuildValue("lllll", |
| _rv, |
| left, |
| top, |
| right, |
| bottom); |
| return _res; |
| } |
| |
| static PyObject *Qt_FlashMediaGetRefConID(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| long refCon; |
| long refConID; |
| #ifndef FlashMediaGetRefConID |
| PyMac_PRECHECK(FlashMediaGetRefConID); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| CmpInstObj_Convert, &mh, |
| &refCon)) |
| return NULL; |
| _rv = FlashMediaGetRefConID(mh, |
| refCon, |
| &refConID); |
| _res = Py_BuildValue("ll", |
| _rv, |
| refConID); |
| return _res; |
| } |
| |
| static PyObject *Qt_FlashMediaIDToRefCon(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| long refConID; |
| long refCon; |
| #ifndef FlashMediaIDToRefCon |
| PyMac_PRECHECK(FlashMediaIDToRefCon); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| CmpInstObj_Convert, &mh, |
| &refConID)) |
| return NULL; |
| _rv = FlashMediaIDToRefCon(mh, |
| refConID, |
| &refCon); |
| _res = Py_BuildValue("ll", |
| _rv, |
| refCon); |
| return _res; |
| } |
| |
| static PyObject *Qt_FlashMediaGetDisplayedFrameNumber(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| long flashFrameNumber; |
| #ifndef FlashMediaGetDisplayedFrameNumber |
| PyMac_PRECHECK(FlashMediaGetDisplayedFrameNumber); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpInstObj_Convert, &mh)) |
| return NULL; |
| _rv = FlashMediaGetDisplayedFrameNumber(mh, |
| &flashFrameNumber); |
| _res = Py_BuildValue("ll", |
| _rv, |
| flashFrameNumber); |
| return _res; |
| } |
| |
| static PyObject *Qt_FlashMediaFrameNumberToMovieTime(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| long flashFrameNumber; |
| TimeValue movieTime; |
| #ifndef FlashMediaFrameNumberToMovieTime |
| PyMac_PRECHECK(FlashMediaFrameNumberToMovieTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| CmpInstObj_Convert, &mh, |
| &flashFrameNumber)) |
| return NULL; |
| _rv = FlashMediaFrameNumberToMovieTime(mh, |
| flashFrameNumber, |
| &movieTime); |
| _res = Py_BuildValue("ll", |
| _rv, |
| movieTime); |
| return _res; |
| } |
| |
| static PyObject *Qt_FlashMediaFrameLabelToMovieTime(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| Ptr theLabel; |
| TimeValue movieTime; |
| #ifndef FlashMediaFrameLabelToMovieTime |
| PyMac_PRECHECK(FlashMediaFrameLabelToMovieTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&s", |
| CmpInstObj_Convert, &mh, |
| &theLabel)) |
| return NULL; |
| _rv = FlashMediaFrameLabelToMovieTime(mh, |
| theLabel, |
| &movieTime); |
| _res = Py_BuildValue("ll", |
| _rv, |
| movieTime); |
| return _res; |
| } |
| |
| static PyObject *Qt_FlashMediaGetFlashVariable(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| char path; |
| char name; |
| Handle theVariableCStringOut; |
| #ifndef FlashMediaGetFlashVariable |
| PyMac_PRECHECK(FlashMediaGetFlashVariable); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpInstObj_Convert, &mh)) |
| return NULL; |
| _rv = FlashMediaGetFlashVariable(mh, |
| &path, |
| &name, |
| &theVariableCStringOut); |
| _res = Py_BuildValue("lccO&", |
| _rv, |
| path, |
| name, |
| ResObj_New, theVariableCStringOut); |
| return _res; |
| } |
| |
| static PyObject *Qt_FlashMediaSetFlashVariable(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| char path; |
| char name; |
| char value; |
| Boolean updateFocus; |
| #ifndef FlashMediaSetFlashVariable |
| PyMac_PRECHECK(FlashMediaSetFlashVariable); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&b", |
| CmpInstObj_Convert, &mh, |
| &updateFocus)) |
| return NULL; |
| _rv = FlashMediaSetFlashVariable(mh, |
| &path, |
| &name, |
| &value, |
| updateFocus); |
| _res = Py_BuildValue("lccc", |
| _rv, |
| path, |
| name, |
| value); |
| return _res; |
| } |
| |
| static PyObject *Qt_FlashMediaDoButtonActions(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| char path; |
| long buttonID; |
| long transition; |
| #ifndef FlashMediaDoButtonActions |
| PyMac_PRECHECK(FlashMediaDoButtonActions); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&ll", |
| CmpInstObj_Convert, &mh, |
| &buttonID, |
| &transition)) |
| return NULL; |
| _rv = FlashMediaDoButtonActions(mh, |
| &path, |
| buttonID, |
| transition); |
| _res = Py_BuildValue("lc", |
| _rv, |
| path); |
| return _res; |
| } |
| |
| static PyObject *Qt_FlashMediaGetSupportedSwfVersion(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| UInt8 swfVersion; |
| #ifndef FlashMediaGetSupportedSwfVersion |
| PyMac_PRECHECK(FlashMediaGetSupportedSwfVersion); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpInstObj_Convert, &mh)) |
| return NULL; |
| _rv = FlashMediaGetSupportedSwfVersion(mh, |
| &swfVersion); |
| _res = Py_BuildValue("lb", |
| _rv, |
| swfVersion); |
| return _res; |
| } |
| |
| static PyObject *Qt_Media3DGetCurrentGroup(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| void * group; |
| #ifndef Media3DGetCurrentGroup |
| PyMac_PRECHECK(Media3DGetCurrentGroup); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&s", |
| CmpInstObj_Convert, &mh, |
| &group)) |
| return NULL; |
| _rv = Media3DGetCurrentGroup(mh, |
| group); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_Media3DTranslateNamedObjectTo(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| char objectName; |
| Fixed x; |
| Fixed y; |
| Fixed z; |
| #ifndef Media3DTranslateNamedObjectTo |
| PyMac_PRECHECK(Media3DTranslateNamedObjectTo); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&O&", |
| CmpInstObj_Convert, &mh, |
| PyMac_GetFixed, &x, |
| PyMac_GetFixed, &y, |
| PyMac_GetFixed, &z)) |
| return NULL; |
| _rv = Media3DTranslateNamedObjectTo(mh, |
| &objectName, |
| x, |
| y, |
| z); |
| _res = Py_BuildValue("lc", |
| _rv, |
| objectName); |
| return _res; |
| } |
| |
| static PyObject *Qt_Media3DScaleNamedObjectTo(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| char objectName; |
| Fixed xScale; |
| Fixed yScale; |
| Fixed zScale; |
| #ifndef Media3DScaleNamedObjectTo |
| PyMac_PRECHECK(Media3DScaleNamedObjectTo); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&O&", |
| CmpInstObj_Convert, &mh, |
| PyMac_GetFixed, &xScale, |
| PyMac_GetFixed, &yScale, |
| PyMac_GetFixed, &zScale)) |
| return NULL; |
| _rv = Media3DScaleNamedObjectTo(mh, |
| &objectName, |
| xScale, |
| yScale, |
| zScale); |
| _res = Py_BuildValue("lc", |
| _rv, |
| objectName); |
| return _res; |
| } |
| |
| static PyObject *Qt_Media3DRotateNamedObjectTo(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| char objectName; |
| Fixed xDegrees; |
| Fixed yDegrees; |
| Fixed zDegrees; |
| #ifndef Media3DRotateNamedObjectTo |
| PyMac_PRECHECK(Media3DRotateNamedObjectTo); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&O&", |
| CmpInstObj_Convert, &mh, |
| PyMac_GetFixed, &xDegrees, |
| PyMac_GetFixed, &yDegrees, |
| PyMac_GetFixed, &zDegrees)) |
| return NULL; |
| _rv = Media3DRotateNamedObjectTo(mh, |
| &objectName, |
| xDegrees, |
| yDegrees, |
| zDegrees); |
| _res = Py_BuildValue("lc", |
| _rv, |
| objectName); |
| return _res; |
| } |
| |
| static PyObject *Qt_Media3DSetCameraData(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| void * cameraData; |
| #ifndef Media3DSetCameraData |
| PyMac_PRECHECK(Media3DSetCameraData); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&s", |
| CmpInstObj_Convert, &mh, |
| &cameraData)) |
| return NULL; |
| _rv = Media3DSetCameraData(mh, |
| cameraData); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_Media3DGetCameraData(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| void * cameraData; |
| #ifndef Media3DGetCameraData |
| PyMac_PRECHECK(Media3DGetCameraData); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&s", |
| CmpInstObj_Convert, &mh, |
| &cameraData)) |
| return NULL; |
| _rv = Media3DGetCameraData(mh, |
| cameraData); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_Media3DSetCameraAngleAspect(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTFloatSingle fov; |
| QTFloatSingle aspectRatioXToY; |
| #ifndef Media3DSetCameraAngleAspect |
| PyMac_PRECHECK(Media3DSetCameraAngleAspect); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&ff", |
| CmpInstObj_Convert, &mh, |
| &fov, |
| &aspectRatioXToY)) |
| return NULL; |
| _rv = Media3DSetCameraAngleAspect(mh, |
| fov, |
| aspectRatioXToY); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_Media3DGetCameraAngleAspect(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTFloatSingle fov; |
| QTFloatSingle aspectRatioXToY; |
| #ifndef Media3DGetCameraAngleAspect |
| PyMac_PRECHECK(Media3DGetCameraAngleAspect); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpInstObj_Convert, &mh)) |
| return NULL; |
| _rv = Media3DGetCameraAngleAspect(mh, |
| &fov, |
| &aspectRatioXToY); |
| _res = Py_BuildValue("lff", |
| _rv, |
| fov, |
| aspectRatioXToY); |
| return _res; |
| } |
| |
| static PyObject *Qt_Media3DSetCameraRange(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| void * tQ3CameraRange; |
| #ifndef Media3DSetCameraRange |
| PyMac_PRECHECK(Media3DSetCameraRange); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&s", |
| CmpInstObj_Convert, &mh, |
| &tQ3CameraRange)) |
| return NULL; |
| _rv = Media3DSetCameraRange(mh, |
| tQ3CameraRange); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_Media3DGetCameraRange(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| void * tQ3CameraRange; |
| #ifndef Media3DGetCameraRange |
| PyMac_PRECHECK(Media3DGetCameraRange); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&s", |
| CmpInstObj_Convert, &mh, |
| &tQ3CameraRange)) |
| return NULL; |
| _rv = Media3DGetCameraRange(mh, |
| tQ3CameraRange); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_NewTimeBase(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeBase _rv; |
| #ifndef NewTimeBase |
| PyMac_PRECHECK(NewTimeBase); |
| #endif |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = NewTimeBase(); |
| _res = Py_BuildValue("O&", |
| TimeBaseObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_ConvertTime(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeRecord theTime; |
| TimeBase newBase; |
| #ifndef ConvertTime |
| PyMac_PRECHECK(ConvertTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| QtTimeRecord_Convert, &theTime, |
| TimeBaseObj_Convert, &newBase)) |
| return NULL; |
| ConvertTime(&theTime, |
| newBase); |
| _res = Py_BuildValue("O&", |
| QtTimeRecord_New, &theTime); |
| return _res; |
| } |
| |
| static PyObject *Qt_ConvertTimeScale(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeRecord theTime; |
| TimeScale newScale; |
| #ifndef ConvertTimeScale |
| PyMac_PRECHECK(ConvertTimeScale); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| QtTimeRecord_Convert, &theTime, |
| &newScale)) |
| return NULL; |
| ConvertTimeScale(&theTime, |
| newScale); |
| _res = Py_BuildValue("O&", |
| QtTimeRecord_New, &theTime); |
| return _res; |
| } |
| |
| static PyObject *Qt_AddTime(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeRecord dst; |
| TimeRecord src; |
| #ifndef AddTime |
| PyMac_PRECHECK(AddTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| QtTimeRecord_Convert, &dst, |
| QtTimeRecord_Convert, &src)) |
| return NULL; |
| AddTime(&dst, |
| &src); |
| _res = Py_BuildValue("O&", |
| QtTimeRecord_New, &dst); |
| return _res; |
| } |
| |
| static PyObject *Qt_SubtractTime(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| TimeRecord dst; |
| TimeRecord src; |
| #ifndef SubtractTime |
| PyMac_PRECHECK(SubtractTime); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| QtTimeRecord_Convert, &dst, |
| QtTimeRecord_Convert, &src)) |
| return NULL; |
| SubtractTime(&dst, |
| &src); |
| _res = Py_BuildValue("O&", |
| QtTimeRecord_New, &dst); |
| return _res; |
| } |
| |
| static PyObject *Qt_MusicMediaGetIndexedTunePlayer(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| ComponentInstance ti; |
| long sampleDescIndex; |
| ComponentInstance tp; |
| #ifndef MusicMediaGetIndexedTunePlayer |
| PyMac_PRECHECK(MusicMediaGetIndexedTunePlayer); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&l", |
| CmpInstObj_Convert, &ti, |
| &sampleDescIndex)) |
| return NULL; |
| _rv = MusicMediaGetIndexedTunePlayer(ti, |
| sampleDescIndex, |
| &tp); |
| _res = Py_BuildValue("lO&", |
| _rv, |
| CmpInstObj_New, tp); |
| return _res; |
| } |
| |
| static PyObject *Qt_AlignWindow(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| WindowPtr wp; |
| Boolean front; |
| #ifndef AlignWindow |
| PyMac_PRECHECK(AlignWindow); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&b", |
| WinObj_Convert, &wp, |
| &front)) |
| return NULL; |
| AlignWindow(wp, |
| front, |
| (Rect *)0, |
| (ICMAlignmentProcRecordPtr)0); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_DragAlignedWindow(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| WindowPtr wp; |
| Point startPt; |
| Rect boundsRect; |
| #ifndef DragAlignedWindow |
| PyMac_PRECHECK(DragAlignedWindow); |
| #endif |
| if (!PyArg_ParseTuple(_args, "O&O&O&", |
| WinObj_Convert, &wp, |
| PyMac_GetPoint, &startPt, |
| PyMac_GetRect, &boundsRect)) |
| return NULL; |
| DragAlignedWindow(wp, |
| startPt, |
| &boundsRect, |
| (Rect *)0, |
| (ICMAlignmentProcRecordPtr)0); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_MoviesTask(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| long maxMilliSecToUse; |
| #ifndef MoviesTask |
| PyMac_PRECHECK(MoviesTask); |
| #endif |
| if (!PyArg_ParseTuple(_args, "l", |
| &maxMilliSecToUse)) |
| return NULL; |
| MoviesTask((Movie)0, |
| maxMilliSecToUse); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyMethodDef Qt_methods[] = { |
| {"EnterMovies", (PyCFunction)Qt_EnterMovies, 1, |
| PyDoc_STR("() -> None")}, |
| {"ExitMovies", (PyCFunction)Qt_ExitMovies, 1, |
| PyDoc_STR("() -> None")}, |
| {"GetMoviesError", (PyCFunction)Qt_GetMoviesError, 1, |
| PyDoc_STR("() -> None")}, |
| {"ClearMoviesStickyError", (PyCFunction)Qt_ClearMoviesStickyError, 1, |
| PyDoc_STR("() -> None")}, |
| {"GetMoviesStickyError", (PyCFunction)Qt_GetMoviesStickyError, 1, |
| PyDoc_STR("() -> None")}, |
| {"DisposeMatte", (PyCFunction)Qt_DisposeMatte, 1, |
| PyDoc_STR("(PixMapHandle theMatte) -> None")}, |
| {"NewMovie", (PyCFunction)Qt_NewMovie, 1, |
| PyDoc_STR("(long flags) -> (Movie _rv)")}, |
| {"GetDataHandler", (PyCFunction)Qt_GetDataHandler, 1, |
| PyDoc_STR("(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)")}, |
| {"PasteHandleIntoMovie", (PyCFunction)Qt_PasteHandleIntoMovie, 1, |
| PyDoc_STR("(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None")}, |
| {"GetMovieImporterForDataRef", (PyCFunction)Qt_GetMovieImporterForDataRef, 1, |
| PyDoc_STR("(OSType dataRefType, Handle dataRef, long flags) -> (Component importer)")}, |
| {"QTGetMIMETypeInfo", (PyCFunction)Qt_QTGetMIMETypeInfo, 1, |
| PyDoc_STR("(char* mimeStringStart, short mimeStringLength, OSType infoSelector, void * infoDataPtr) -> (long infoDataSize)")}, |
| {"TrackTimeToMediaTime", (PyCFunction)Qt_TrackTimeToMediaTime, 1, |
| PyDoc_STR("(TimeValue value, Track theTrack) -> (TimeValue _rv)")}, |
| {"NewUserData", (PyCFunction)Qt_NewUserData, 1, |
| PyDoc_STR("() -> (UserData theUserData)")}, |
| {"NewUserDataFromHandle", (PyCFunction)Qt_NewUserDataFromHandle, 1, |
| PyDoc_STR("(Handle h) -> (UserData theUserData)")}, |
| {"CreateMovieFile", (PyCFunction)Qt_CreateMovieFile, 1, |
| PyDoc_STR("(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (short resRefNum, Movie newmovie)")}, |
| {"OpenMovieFile", (PyCFunction)Qt_OpenMovieFile, 1, |
| PyDoc_STR("(FSSpec fileSpec, SInt8 permission) -> (short resRefNum)")}, |
| {"CloseMovieFile", (PyCFunction)Qt_CloseMovieFile, 1, |
| PyDoc_STR("(short resRefNum) -> None")}, |
| {"DeleteMovieFile", (PyCFunction)Qt_DeleteMovieFile, 1, |
| PyDoc_STR("(FSSpec fileSpec) -> None")}, |
| {"NewMovieFromFile", (PyCFunction)Qt_NewMovieFromFile, 1, |
| PyDoc_STR("(short resRefNum, short resId, short newMovieFlags) -> (Movie theMovie, short resId, Boolean dataRefWasChanged)")}, |
| {"NewMovieFromHandle", (PyCFunction)Qt_NewMovieFromHandle, 1, |
| PyDoc_STR("(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")}, |
| {"NewMovieFromDataFork", (PyCFunction)Qt_NewMovieFromDataFork, 1, |
| PyDoc_STR("(short fRefNum, long fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")}, |
| {"NewMovieFromDataFork64", (PyCFunction)Qt_NewMovieFromDataFork64, 1, |
| PyDoc_STR("(long fRefNum, wide fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")}, |
| {"NewMovieFromDataRef", (PyCFunction)Qt_NewMovieFromDataRef, 1, |
| PyDoc_STR("(short flags, Handle dataRef, OSType dataRefType) -> (Movie m, short id)")}, |
| {"RemoveMovieResource", (PyCFunction)Qt_RemoveMovieResource, 1, |
| PyDoc_STR("(short resRefNum, short resId) -> None")}, |
| {"CreateShortcutMovieFile", (PyCFunction)Qt_CreateShortcutMovieFile, 1, |
| PyDoc_STR("(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Handle targetDataRef, OSType targetDataRefType) -> None")}, |
| {"CanQuickTimeOpenFile", (PyCFunction)Qt_CanQuickTimeOpenFile, 1, |
| PyDoc_STR("(FSSpec fileSpec, OSType fileType, OSType fileNameExtension, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)")}, |
| {"CanQuickTimeOpenDataRef", (PyCFunction)Qt_CanQuickTimeOpenDataRef, 1, |
| PyDoc_STR("(Handle dataRef, OSType dataRefType, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)")}, |
| {"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1, |
| PyDoc_STR("(long newMovieFlags) -> (Movie _rv)")}, |
| {"QTNewAlias", (PyCFunction)Qt_QTNewAlias, 1, |
| PyDoc_STR("(FSSpec fss, Boolean minimal) -> (AliasHandle alias)")}, |
| {"EndFullScreen", (PyCFunction)Qt_EndFullScreen, 1, |
| PyDoc_STR("(Ptr fullState, long flags) -> None")}, |
| {"AddSoundDescriptionExtension", (PyCFunction)Qt_AddSoundDescriptionExtension, 1, |
| PyDoc_STR("(SoundDescriptionHandle desc, Handle extension, OSType idType) -> None")}, |
| {"GetSoundDescriptionExtension", (PyCFunction)Qt_GetSoundDescriptionExtension, 1, |
| PyDoc_STR("(SoundDescriptionHandle desc, OSType idType) -> (Handle extension)")}, |
| {"RemoveSoundDescriptionExtension", (PyCFunction)Qt_RemoveSoundDescriptionExtension, 1, |
| PyDoc_STR("(SoundDescriptionHandle desc, OSType idType) -> None")}, |
| {"QTIsStandardParameterDialogEvent", (PyCFunction)Qt_QTIsStandardParameterDialogEvent, 1, |
| PyDoc_STR("(QTParameterDialog createdDialog) -> (EventRecord pEvent)")}, |
| {"QTDismissStandardParameterDialog", (PyCFunction)Qt_QTDismissStandardParameterDialog, 1, |
| PyDoc_STR("(QTParameterDialog createdDialog) -> None")}, |
| {"QTStandardParameterDialogDoAction", (PyCFunction)Qt_QTStandardParameterDialogDoAction, 1, |
| PyDoc_STR("(QTParameterDialog createdDialog, long action, void * params) -> None")}, |
| {"QTRegisterAccessKey", (PyCFunction)Qt_QTRegisterAccessKey, 1, |
| PyDoc_STR("(Str255 accessKeyType, long flags, Handle accessKey) -> None")}, |
| {"QTUnregisterAccessKey", (PyCFunction)Qt_QTUnregisterAccessKey, 1, |
| PyDoc_STR("(Str255 accessKeyType, long flags, Handle accessKey) -> None")}, |
| {"QTTextToNativeText", (PyCFunction)Qt_QTTextToNativeText, 1, |
| PyDoc_STR("(Handle theText, long encoding, long flags) -> None")}, |
| {"VideoMediaResetStatistics", (PyCFunction)Qt_VideoMediaResetStatistics, 1, |
| PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")}, |
| {"VideoMediaGetStatistics", (PyCFunction)Qt_VideoMediaGetStatistics, 1, |
| PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")}, |
| {"VideoMediaGetStallCount", (PyCFunction)Qt_VideoMediaGetStallCount, 1, |
| PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, unsigned long stalls)")}, |
| {"VideoMediaSetCodecParameter", (PyCFunction)Qt_VideoMediaSetCodecParameter, 1, |
| PyDoc_STR("(MediaHandler mh, CodecType cType, OSType parameterID, long parameterChangeSeed, void * dataPtr, long dataSize) -> (ComponentResult _rv)")}, |
| {"VideoMediaGetCodecParameter", (PyCFunction)Qt_VideoMediaGetCodecParameter, 1, |
| PyDoc_STR("(MediaHandler mh, CodecType cType, OSType parameterID, Handle outParameterData) -> (ComponentResult _rv)")}, |
| {"TextMediaAddTextSample", (PyCFunction)Qt_TextMediaAddTextSample, 1, |
| PyDoc_STR("(MediaHandler mh, Ptr text, unsigned long size, short fontNumber, short fontSize, Style textFace, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor textColor, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)")}, |
| {"TextMediaAddTESample", (PyCFunction)Qt_TextMediaAddTESample, 1, |
| PyDoc_STR("(MediaHandler mh, TEHandle hTE, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)")}, |
| {"TextMediaAddHiliteSample", (PyCFunction)Qt_TextMediaAddHiliteSample, 1, |
| PyDoc_STR("(MediaHandler mh, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor rgbHiliteColor, TimeValue sampleTime)")}, |
| {"TextMediaDrawRaw", (PyCFunction)Qt_TextMediaDrawRaw, 1, |
| PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh) -> (ComponentResult _rv)")}, |
| {"TextMediaSetTextProperty", (PyCFunction)Qt_TextMediaSetTextProperty, 1, |
| PyDoc_STR("(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)")}, |
| {"TextMediaRawSetup", (PyCFunction)Qt_TextMediaRawSetup, 1, |
| PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh, TimeValue sampleDuration) -> (ComponentResult _rv)")}, |
| {"TextMediaRawIdle", (PyCFunction)Qt_TextMediaRawIdle, 1, |
| PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, TimeValue sampleTime, long flagsIn) -> (ComponentResult _rv, long flagsOut)")}, |
| {"TextMediaGetTextProperty", (PyCFunction)Qt_TextMediaGetTextProperty, 1, |
| PyDoc_STR("(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)")}, |
| {"TextMediaFindNextText", (PyCFunction)Qt_TextMediaFindNextText, 1, |
| PyDoc_STR("(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)")}, |
| {"TextMediaHiliteTextSample", (PyCFunction)Qt_TextMediaHiliteTextSample, 1, |
| PyDoc_STR("(MediaHandler mh, TimeValue sampleTime, short hiliteStart, short hiliteEnd) -> (ComponentResult _rv, RGBColor rgbHiliteColor)")}, |
| {"TextMediaSetTextSampleData", (PyCFunction)Qt_TextMediaSetTextSampleData, 1, |
| PyDoc_STR("(MediaHandler mh, void * data, OSType dataType) -> (ComponentResult _rv)")}, |
| {"SpriteMediaSetProperty", (PyCFunction)Qt_SpriteMediaSetProperty, 1, |
| PyDoc_STR("(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)")}, |
| {"SpriteMediaGetProperty", (PyCFunction)Qt_SpriteMediaGetProperty, 1, |
| PyDoc_STR("(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)")}, |
| {"SpriteMediaHitTestSprites", (PyCFunction)Qt_SpriteMediaHitTestSprites, 1, |
| PyDoc_STR("(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, short spriteHitIndex)")}, |
| {"SpriteMediaCountSprites", (PyCFunction)Qt_SpriteMediaCountSprites, 1, |
| PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short numSprites)")}, |
| {"SpriteMediaCountImages", (PyCFunction)Qt_SpriteMediaCountImages, 1, |
| PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short numImages)")}, |
| {"SpriteMediaGetIndImageDescription", (PyCFunction)Qt_SpriteMediaGetIndImageDescription, 1, |
| PyDoc_STR("(MediaHandler mh, short imageIndex, ImageDescriptionHandle imageDescription) -> (ComponentResult _rv)")}, |
| {"SpriteMediaGetDisplayedSampleNumber", (PyCFunction)Qt_SpriteMediaGetDisplayedSampleNumber, 1, |
| PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long sampleNum)")}, |
| {"SpriteMediaGetSpriteName", (PyCFunction)Qt_SpriteMediaGetSpriteName, 1, |
| PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, Str255 spriteName) -> (ComponentResult _rv)")}, |
| {"SpriteMediaGetImageName", (PyCFunction)Qt_SpriteMediaGetImageName, 1, |
| PyDoc_STR("(MediaHandler mh, short imageIndex, Str255 imageName) -> (ComponentResult _rv)")}, |
| {"SpriteMediaSetSpriteProperty", (PyCFunction)Qt_SpriteMediaSetSpriteProperty, 1, |
| PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)")}, |
| {"SpriteMediaGetSpriteProperty", (PyCFunction)Qt_SpriteMediaGetSpriteProperty, 1, |
| PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)")}, |
| {"SpriteMediaHitTestAllSprites", (PyCFunction)Qt_SpriteMediaHitTestAllSprites, 1, |
| PyDoc_STR("(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, QTAtomID spriteHitID)")}, |
| {"SpriteMediaHitTestOneSprite", (PyCFunction)Qt_SpriteMediaHitTestOneSprite, 1, |
| PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long flags, Point loc) -> (ComponentResult _rv, Boolean wasHit)")}, |
| {"SpriteMediaSpriteIndexToID", (PyCFunction)Qt_SpriteMediaSpriteIndexToID, 1, |
| PyDoc_STR("(MediaHandler mh, short spriteIndex) -> (ComponentResult _rv, QTAtomID spriteID)")}, |
| {"SpriteMediaSpriteIDToIndex", (PyCFunction)Qt_SpriteMediaSpriteIDToIndex, 1, |
| PyDoc_STR("(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv, short spriteIndex)")}, |
| {"SpriteMediaSetActionVariable", (PyCFunction)Qt_SpriteMediaSetActionVariable, 1, |
| PyDoc_STR("(MediaHandler mh, QTAtomID variableID, float value) -> (ComponentResult _rv)")}, |
| {"SpriteMediaGetActionVariable", (PyCFunction)Qt_SpriteMediaGetActionVariable, 1, |
| PyDoc_STR("(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, float value)")}, |
| {"SpriteMediaDisposeSprite", (PyCFunction)Qt_SpriteMediaDisposeSprite, 1, |
| PyDoc_STR("(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv)")}, |
| {"SpriteMediaSetActionVariableToString", (PyCFunction)Qt_SpriteMediaSetActionVariableToString, 1, |
| PyDoc_STR("(MediaHandler mh, QTAtomID variableID, Ptr theCString) -> (ComponentResult _rv)")}, |
| {"SpriteMediaGetActionVariableAsString", (PyCFunction)Qt_SpriteMediaGetActionVariableAsString, 1, |
| PyDoc_STR("(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, Handle theCString)")}, |
| {"FlashMediaSetPan", (PyCFunction)Qt_FlashMediaSetPan, 1, |
| PyDoc_STR("(MediaHandler mh, short xPercent, short yPercent) -> (ComponentResult _rv)")}, |
| {"FlashMediaSetZoom", (PyCFunction)Qt_FlashMediaSetZoom, 1, |
| PyDoc_STR("(MediaHandler mh, short factor) -> (ComponentResult _rv)")}, |
| {"FlashMediaSetZoomRect", (PyCFunction)Qt_FlashMediaSetZoomRect, 1, |
| PyDoc_STR("(MediaHandler mh, long left, long top, long right, long bottom) -> (ComponentResult _rv)")}, |
| {"FlashMediaGetRefConBounds", (PyCFunction)Qt_FlashMediaGetRefConBounds, 1, |
| PyDoc_STR("(MediaHandler mh, long refCon) -> (ComponentResult _rv, long left, long top, long right, long bottom)")}, |
| {"FlashMediaGetRefConID", (PyCFunction)Qt_FlashMediaGetRefConID, 1, |
| PyDoc_STR("(MediaHandler mh, long refCon) -> (ComponentResult _rv, long refConID)")}, |
| {"FlashMediaIDToRefCon", (PyCFunction)Qt_FlashMediaIDToRefCon, 1, |
| PyDoc_STR("(MediaHandler mh, long refConID) -> (ComponentResult _rv, long refCon)")}, |
| {"FlashMediaGetDisplayedFrameNumber", (PyCFunction)Qt_FlashMediaGetDisplayedFrameNumber, 1, |
| PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long flashFrameNumber)")}, |
| {"FlashMediaFrameNumberToMovieTime", (PyCFunction)Qt_FlashMediaFrameNumberToMovieTime, 1, |
| PyDoc_STR("(MediaHandler mh, long flashFrameNumber) -> (ComponentResult _rv, TimeValue movieTime)")}, |
| {"FlashMediaFrameLabelToMovieTime", (PyCFunction)Qt_FlashMediaFrameLabelToMovieTime, 1, |
| PyDoc_STR("(MediaHandler mh, Ptr theLabel) -> (ComponentResult _rv, TimeValue movieTime)")}, |
| {"FlashMediaGetFlashVariable", (PyCFunction)Qt_FlashMediaGetFlashVariable, 1, |
| PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, char path, char name, Handle theVariableCStringOut)")}, |
| {"FlashMediaSetFlashVariable", (PyCFunction)Qt_FlashMediaSetFlashVariable, 1, |
| PyDoc_STR("(MediaHandler mh, Boolean updateFocus) -> (ComponentResult _rv, char path, char name, char value)")}, |
| {"FlashMediaDoButtonActions", (PyCFunction)Qt_FlashMediaDoButtonActions, 1, |
| PyDoc_STR("(MediaHandler mh, long buttonID, long transition) -> (ComponentResult _rv, char path)")}, |
| {"FlashMediaGetSupportedSwfVersion", (PyCFunction)Qt_FlashMediaGetSupportedSwfVersion, 1, |
| PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, UInt8 swfVersion)")}, |
| {"Media3DGetCurrentGroup", (PyCFunction)Qt_Media3DGetCurrentGroup, 1, |
| PyDoc_STR("(MediaHandler mh, void * group) -> (ComponentResult _rv)")}, |
| {"Media3DTranslateNamedObjectTo", (PyCFunction)Qt_Media3DTranslateNamedObjectTo, 1, |
| PyDoc_STR("(MediaHandler mh, Fixed x, Fixed y, Fixed z) -> (ComponentResult _rv, char objectName)")}, |
| {"Media3DScaleNamedObjectTo", (PyCFunction)Qt_Media3DScaleNamedObjectTo, 1, |
| PyDoc_STR("(MediaHandler mh, Fixed xScale, Fixed yScale, Fixed zScale) -> (ComponentResult _rv, char objectName)")}, |
| {"Media3DRotateNamedObjectTo", (PyCFunction)Qt_Media3DRotateNamedObjectTo, 1, |
| PyDoc_STR("(MediaHandler mh, Fixed xDegrees, Fixed yDegrees, Fixed zDegrees) -> (ComponentResult _rv, char objectName)")}, |
| {"Media3DSetCameraData", (PyCFunction)Qt_Media3DSetCameraData, 1, |
| PyDoc_STR("(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)")}, |
| {"Media3DGetCameraData", (PyCFunction)Qt_Media3DGetCameraData, 1, |
| PyDoc_STR("(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)")}, |
| {"Media3DSetCameraAngleAspect", (PyCFunction)Qt_Media3DSetCameraAngleAspect, 1, |
| PyDoc_STR("(MediaHandler mh, QTFloatSingle fov, QTFloatSingle aspectRatioXToY) -> (ComponentResult _rv)")}, |
| {"Media3DGetCameraAngleAspect", (PyCFunction)Qt_Media3DGetCameraAngleAspect, 1, |
| PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, QTFloatSingle fov, QTFloatSingle aspectRatioXToY)")}, |
| {"Media3DSetCameraRange", (PyCFunction)Qt_Media3DSetCameraRange, 1, |
| PyDoc_STR("(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)")}, |
| {"Media3DGetCameraRange", (PyCFunction)Qt_Media3DGetCameraRange, 1, |
| PyDoc_STR("(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)")}, |
| {"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1, |
| PyDoc_STR("() -> (TimeBase _rv)")}, |
| {"ConvertTime", (PyCFunction)Qt_ConvertTime, 1, |
| PyDoc_STR("(TimeRecord theTime, TimeBase newBase) -> (TimeRecord theTime)")}, |
| {"ConvertTimeScale", (PyCFunction)Qt_ConvertTimeScale, 1, |
| PyDoc_STR("(TimeRecord theTime, TimeScale newScale) -> (TimeRecord theTime)")}, |
| {"AddTime", (PyCFunction)Qt_AddTime, 1, |
| PyDoc_STR("(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)")}, |
| {"SubtractTime", (PyCFunction)Qt_SubtractTime, 1, |
| PyDoc_STR("(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)")}, |
| {"MusicMediaGetIndexedTunePlayer", (PyCFunction)Qt_MusicMediaGetIndexedTunePlayer, 1, |
| PyDoc_STR("(ComponentInstance ti, long sampleDescIndex) -> (ComponentResult _rv, ComponentInstance tp)")}, |
| {"AlignWindow", (PyCFunction)Qt_AlignWindow, 1, |
| PyDoc_STR("(WindowPtr wp, Boolean front) -> None")}, |
| {"DragAlignedWindow", (PyCFunction)Qt_DragAlignedWindow, 1, |
| PyDoc_STR("(WindowPtr wp, Point startPt, Rect boundsRect) -> None")}, |
| {"MoviesTask", (PyCFunction)Qt_MoviesTask, 1, |
| PyDoc_STR("(long maxMilliSecToUse) -> None")}, |
| {NULL, NULL, 0} |
| }; |
| |
| |
| |
| |
| void init_Qt(void) |
| { |
| PyObject *m; |
| PyObject *d; |
| |
| |
| |
| PyMac_INIT_TOOLBOX_OBJECT_NEW(Track, TrackObj_New); |
| PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Track, TrackObj_Convert); |
| PyMac_INIT_TOOLBOX_OBJECT_NEW(Movie, MovieObj_New); |
| PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Movie, MovieObj_Convert); |
| PyMac_INIT_TOOLBOX_OBJECT_NEW(MovieController, MovieCtlObj_New); |
| PyMac_INIT_TOOLBOX_OBJECT_CONVERT(MovieController, MovieCtlObj_Convert); |
| PyMac_INIT_TOOLBOX_OBJECT_NEW(TimeBase, TimeBaseObj_New); |
| PyMac_INIT_TOOLBOX_OBJECT_CONVERT(TimeBase, TimeBaseObj_Convert); |
| PyMac_INIT_TOOLBOX_OBJECT_NEW(UserData, UserDataObj_New); |
| PyMac_INIT_TOOLBOX_OBJECT_CONVERT(UserData, UserDataObj_Convert); |
| PyMac_INIT_TOOLBOX_OBJECT_NEW(Media, MediaObj_New); |
| PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Media, MediaObj_Convert); |
| |
| |
| m = Py_InitModule("_Qt", Qt_methods); |
| d = PyModule_GetDict(m); |
| Qt_Error = PyMac_GetOSErrException(); |
| if (Qt_Error == NULL || |
| PyDict_SetItemString(d, "Error", Qt_Error) != 0) |
| return; |
| MovieController_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&MovieController_Type) < 0) return; |
| Py_INCREF(&MovieController_Type); |
| PyModule_AddObject(m, "MovieController", (PyObject *)&MovieController_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&MovieController_Type); |
| PyModule_AddObject(m, "MovieControllerType", (PyObject *)&MovieController_Type); |
| TimeBase_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&TimeBase_Type) < 0) return; |
| Py_INCREF(&TimeBase_Type); |
| PyModule_AddObject(m, "TimeBase", (PyObject *)&TimeBase_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&TimeBase_Type); |
| PyModule_AddObject(m, "TimeBaseType", (PyObject *)&TimeBase_Type); |
| UserData_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&UserData_Type) < 0) return; |
| Py_INCREF(&UserData_Type); |
| PyModule_AddObject(m, "UserData", (PyObject *)&UserData_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&UserData_Type); |
| PyModule_AddObject(m, "UserDataType", (PyObject *)&UserData_Type); |
| Media_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&Media_Type) < 0) return; |
| Py_INCREF(&Media_Type); |
| PyModule_AddObject(m, "Media", (PyObject *)&Media_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&Media_Type); |
| PyModule_AddObject(m, "MediaType", (PyObject *)&Media_Type); |
| Track_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&Track_Type) < 0) return; |
| Py_INCREF(&Track_Type); |
| PyModule_AddObject(m, "Track", (PyObject *)&Track_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&Track_Type); |
| PyModule_AddObject(m, "TrackType", (PyObject *)&Track_Type); |
| Movie_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&Movie_Type) < 0) return; |
| Py_INCREF(&Movie_Type); |
| PyModule_AddObject(m, "Movie", (PyObject *)&Movie_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&Movie_Type); |
| PyModule_AddObject(m, "MovieType", (PyObject *)&Movie_Type); |
| } |
| |
| /* ========================= End module _Qt ========================= */ |
| |