| |
| /* =========================== Module Qt ============================ */ |
| |
| #include "Python.h" |
| |
| |
| |
| #define SystemSevenOrLater 1 |
| |
| #include "macglue.h" |
| #include <Memory.h> |
| #include <Dialogs.h> |
| #include <Menus.h> |
| #include <Controls.h> |
| |
| extern PyObject *ResObj_New(Handle); |
| extern int ResObj_Convert(PyObject *, Handle *); |
| extern PyObject *OptResObj_New(Handle); |
| extern int OptResObj_Convert(PyObject *, Handle *); |
| |
| extern PyObject *WinObj_New(WindowPtr); |
| extern int WinObj_Convert(PyObject *, WindowPtr *); |
| extern PyTypeObject Window_Type; |
| #define WinObj_Check(x) ((x)->ob_type == &Window_Type) |
| |
| extern PyObject *DlgObj_New(DialogPtr); |
| extern int DlgObj_Convert(PyObject *, DialogPtr *); |
| extern PyTypeObject Dialog_Type; |
| #define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type) |
| |
| extern PyObject *MenuObj_New(MenuHandle); |
| extern int MenuObj_Convert(PyObject *, MenuHandle *); |
| |
| extern PyObject *CtlObj_New(ControlHandle); |
| extern int CtlObj_Convert(PyObject *, ControlHandle *); |
| |
| extern PyObject *GrafObj_New(GrafPtr); |
| extern int GrafObj_Convert(PyObject *, GrafPtr *); |
| |
| extern PyObject *BMObj_New(BitMapPtr); |
| extern int BMObj_Convert(PyObject *, BitMapPtr *); |
| |
| extern PyObject *WinObj_WhichWindow(WindowPtr); |
| |
| #include <Movies.h> |
| |
| /* Exported by Cmmodule.c: */ |
| extern PyObject *CmpObj_New(Component); |
| extern int CmpObj_Convert(PyObject *, Component *); |
| extern PyObject *CmpInstObj_New(ComponentInstance); |
| extern int CmpInstObj_Convert(PyObject *, ComponentInstance *); |
| |
| /* Exported by Qdmodule.c: */ |
| extern PyObject *QdRGB_New(RGBColor *); |
| extern int QdRGB_Convert(PyObject *, RGBColor *); |
| |
| /* Our own, used before defined: */ |
| staticforward PyObject *TrackObj_New(Track); |
| staticforward int TrackObj_Convert(PyObject *, Track *); |
| staticforward PyObject *MovieObj_New(Movie); |
| staticforward int MovieObj_Convert(PyObject *, Movie *); |
| staticforward PyObject *MovieCtlObj_New(MovieController); |
| staticforward int MovieCtlObj_Convert(PyObject *, TimeBase *); |
| staticforward PyObject *TimeBaseObj_New(TimeBase); |
| staticforward int TimeBaseObj_Convert(PyObject *, TimeBase *); |
| |
| /* |
| ** Parse/generate time records |
| */ |
| static PyObject * |
| QtTimeRecord_New(itself) |
| TimeRecord *itself; |
| { |
| |
| return Py_BuildValue("O&lO&", PyMac_Buildwide, &itself->value, itself->scale, |
| TimeBaseObj_New, itself->base); |
| } |
| |
| static int |
| QtTimeRecord_Convert(v, p_itself) |
| PyObject *v; |
| TimeRecord *p_itself; |
| { |
| |
| if( !PyArg_ParseTuple(v, "O&lO&", PyMac_Getwide, &p_itself->value, &p_itself->scale, |
| TimeBaseObj_Convert, &p_itself->base) ) |
| return 0; |
| return 1; |
| } |
| |
| |
| |
| |
| static PyObject *Qt_Error; |
| |
| /* ------------------ Object type MovieController ------------------- */ |
| |
| PyTypeObject MovieController_Type; |
| |
| #define MovieCtlObj_Check(x) ((x)->ob_type == &MovieController_Type) |
| |
| typedef struct MovieControllerObject { |
| PyObject_HEAD |
| MovieController ob_itself; |
| } MovieControllerObject; |
| |
| PyObject *MovieCtlObj_New(itself) |
| 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; |
| } |
| MovieCtlObj_Convert(v, p_itself) |
| 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(self) |
| MovieControllerObject *self; |
| { |
| DisposeMovieController(self->ob_itself); |
| PyMem_DEL(self); |
| } |
| |
| static PyObject *MovieCtlObj_MCSetMovie(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Movie theMovie; |
| WindowPtr movieWindow; |
| Point where; |
| if (!PyArg_ParseTuple(_args, "O&O&O&", |
| MovieObj_Convert, &theMovie, |
| WinObj_Convert, &movieWindow, |
| PyMac_GetPoint, &where)) |
| return NULL; |
| _rv = MCSetMovie(_self->ob_itself, |
| theMovie, |
| movieWindow, |
| where); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetIndMovie(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| short index; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCRemoveAllMovies(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCRemoveAMovie(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Movie m; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCRemoveMovie(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCIsPlayerEvent(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| EventRecord e; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| short action; |
| void * params; |
| if (!PyArg_ParseTuple(_args, "hs", |
| &action, |
| ¶ms)) |
| return NULL; |
| _rv = MCDoAction(_self->ob_itself, |
| action, |
| params); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCSetControllerAttached(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Boolean attach; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCIsControllerAttached(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCSetControllerPort(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| CGrafPtr gp; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| CGrafPtr _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCGetControllerPort(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| GrafObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCSetVisible(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Boolean visible; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCGetVisible(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetControllerBoundsRect(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Rect bounds; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCGetControllerBoundsRect(_self->ob_itself, |
| &bounds); |
| _res = Py_BuildValue("lO&", |
| _rv, |
| PyMac_BuildRect, &bounds); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCSetControllerBoundsRect(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Rect bounds; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetRect, &bounds)) |
| return NULL; |
| _rv = MCSetControllerBoundsRect(_self->ob_itself, |
| &bounds); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetControllerBoundsRgn(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCGetControllerBoundsRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCGetWindowRgn(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| WindowPtr w; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Movie m; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| TimeValue duration; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| TimeScale scale; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCGetCurrentTime(_self->ob_itself, |
| &scale); |
| _res = Py_BuildValue("ll", |
| _rv, |
| scale); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCNewAttachedController(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Movie theMovie; |
| WindowPtr w; |
| Point where; |
| if (!PyArg_ParseTuple(_args, "O&O&O&", |
| MovieObj_Convert, &theMovie, |
| WinObj_Convert, &w, |
| PyMac_GetPoint, &where)) |
| return NULL; |
| _rv = MCNewAttachedController(_self->ob_itself, |
| theMovie, |
| w, |
| where); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCDraw(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| WindowPtr w; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| WindowPtr w; |
| Boolean activate; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCIdle(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCKey(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| SInt8 key; |
| long modifiers; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| WindowPtr w; |
| Point where; |
| long when; |
| long modifiers; |
| if (!PyArg_ParseTuple(_args, "O&O&ll", |
| WinObj_Convert, &w, |
| PyMac_GetPoint, &where, |
| &when, |
| &modifiers)) |
| return NULL; |
| _rv = MCClick(_self->ob_itself, |
| w, |
| where, |
| when, |
| modifiers); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCEnableEditing(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Boolean enabled; |
| if (!PyArg_ParseTuple(_args, "b", |
| &enabled)) |
| return NULL; |
| _rv = MCEnableEditing(_self->ob_itself, |
| enabled); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCIsEditingEnabled(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCIsEditingEnabled(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCCopy(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCCopy(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCCut(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCCut(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCPaste(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Movie srcMovie; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCClear(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCUndo(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCUndo(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCPositionController(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Rect movieRect; |
| Rect controllerRect; |
| long someFlags; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| long someFlags; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = MCGetControllerInfo(_self->ob_itself, |
| &someFlags); |
| _res = Py_BuildValue("ll", |
| _rv, |
| someFlags); |
| return _res; |
| } |
| |
| static PyObject *MovieCtlObj_MCSetClip(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| RgnHandle theClip; |
| RgnHandle movieClip; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| RgnHandle theClip; |
| RgnHandle movieClip; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| RgnHandle movieRgn; |
| RgnHandle badgeRgn; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| long modifiers; |
| MenuHandle mh; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| long modifiers; |
| short item; |
| Str255 aString; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Point thePt; |
| Boolean inController; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| WindowPtr w; |
| RgnHandle invalidRgn; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| WindowPtr w; |
| Point where; |
| long modifiers; |
| 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(_self, _args) |
| MovieControllerObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MCInterfaceElement whichElement; |
| void * element; |
| if (!PyArg_ParseTuple(_args, "ls", |
| &whichElement, |
| &element)) |
| return NULL; |
| _rv = MCGetInterfaceElement(_self->ob_itself, |
| whichElement, |
| element); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyMethodDef MovieCtlObj_methods[] = { |
| {"MCSetMovie", (PyCFunction)MovieCtlObj_MCSetMovie, 1, |
| "(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)"}, |
| {"MCGetIndMovie", (PyCFunction)MovieCtlObj_MCGetIndMovie, 1, |
| "(short index) -> (Movie _rv)"}, |
| {"MCRemoveAllMovies", (PyCFunction)MovieCtlObj_MCRemoveAllMovies, 1, |
| "() -> (ComponentResult _rv)"}, |
| {"MCRemoveAMovie", (PyCFunction)MovieCtlObj_MCRemoveAMovie, 1, |
| "(Movie m) -> (ComponentResult _rv)"}, |
| {"MCRemoveMovie", (PyCFunction)MovieCtlObj_MCRemoveMovie, 1, |
| "() -> (ComponentResult _rv)"}, |
| {"MCIsPlayerEvent", (PyCFunction)MovieCtlObj_MCIsPlayerEvent, 1, |
| "(EventRecord e) -> (ComponentResult _rv)"}, |
| {"MCDoAction", (PyCFunction)MovieCtlObj_MCDoAction, 1, |
| "(short action, void * params) -> (ComponentResult _rv)"}, |
| {"MCSetControllerAttached", (PyCFunction)MovieCtlObj_MCSetControllerAttached, 1, |
| "(Boolean attach) -> (ComponentResult _rv)"}, |
| {"MCIsControllerAttached", (PyCFunction)MovieCtlObj_MCIsControllerAttached, 1, |
| "() -> (ComponentResult _rv)"}, |
| {"MCSetControllerPort", (PyCFunction)MovieCtlObj_MCSetControllerPort, 1, |
| "(CGrafPtr gp) -> (ComponentResult _rv)"}, |
| {"MCGetControllerPort", (PyCFunction)MovieCtlObj_MCGetControllerPort, 1, |
| "() -> (CGrafPtr _rv)"}, |
| {"MCSetVisible", (PyCFunction)MovieCtlObj_MCSetVisible, 1, |
| "(Boolean visible) -> (ComponentResult _rv)"}, |
| {"MCGetVisible", (PyCFunction)MovieCtlObj_MCGetVisible, 1, |
| "() -> (ComponentResult _rv)"}, |
| {"MCGetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRect, 1, |
| "() -> (ComponentResult _rv, Rect bounds)"}, |
| {"MCSetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCSetControllerBoundsRect, 1, |
| "(Rect bounds) -> (ComponentResult _rv)"}, |
| {"MCGetControllerBoundsRgn", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRgn, 1, |
| "() -> (RgnHandle _rv)"}, |
| {"MCGetWindowRgn", (PyCFunction)MovieCtlObj_MCGetWindowRgn, 1, |
| "(WindowPtr w) -> (RgnHandle _rv)"}, |
| {"MCMovieChanged", (PyCFunction)MovieCtlObj_MCMovieChanged, 1, |
| "(Movie m) -> (ComponentResult _rv)"}, |
| {"MCSetDuration", (PyCFunction)MovieCtlObj_MCSetDuration, 1, |
| "(TimeValue duration) -> (ComponentResult _rv)"}, |
| {"MCGetCurrentTime", (PyCFunction)MovieCtlObj_MCGetCurrentTime, 1, |
| "() -> (TimeValue _rv, TimeScale scale)"}, |
| {"MCNewAttachedController", (PyCFunction)MovieCtlObj_MCNewAttachedController, 1, |
| "(Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)"}, |
| {"MCDraw", (PyCFunction)MovieCtlObj_MCDraw, 1, |
| "(WindowPtr w) -> (ComponentResult _rv)"}, |
| {"MCActivate", (PyCFunction)MovieCtlObj_MCActivate, 1, |
| "(WindowPtr w, Boolean activate) -> (ComponentResult _rv)"}, |
| {"MCIdle", (PyCFunction)MovieCtlObj_MCIdle, 1, |
| "() -> (ComponentResult _rv)"}, |
| {"MCKey", (PyCFunction)MovieCtlObj_MCKey, 1, |
| "(SInt8 key, long modifiers) -> (ComponentResult _rv)"}, |
| {"MCClick", (PyCFunction)MovieCtlObj_MCClick, 1, |
| "(WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)"}, |
| {"MCEnableEditing", (PyCFunction)MovieCtlObj_MCEnableEditing, 1, |
| "(Boolean enabled) -> (ComponentResult _rv)"}, |
| {"MCIsEditingEnabled", (PyCFunction)MovieCtlObj_MCIsEditingEnabled, 1, |
| "() -> (long _rv)"}, |
| {"MCCopy", (PyCFunction)MovieCtlObj_MCCopy, 1, |
| "() -> (Movie _rv)"}, |
| {"MCCut", (PyCFunction)MovieCtlObj_MCCut, 1, |
| "() -> (Movie _rv)"}, |
| {"MCPaste", (PyCFunction)MovieCtlObj_MCPaste, 1, |
| "(Movie srcMovie) -> (ComponentResult _rv)"}, |
| {"MCClear", (PyCFunction)MovieCtlObj_MCClear, 1, |
| "() -> (ComponentResult _rv)"}, |
| {"MCUndo", (PyCFunction)MovieCtlObj_MCUndo, 1, |
| "() -> (ComponentResult _rv)"}, |
| {"MCPositionController", (PyCFunction)MovieCtlObj_MCPositionController, 1, |
| "(Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)"}, |
| {"MCGetControllerInfo", (PyCFunction)MovieCtlObj_MCGetControllerInfo, 1, |
| "() -> (ComponentResult _rv, long someFlags)"}, |
| {"MCSetClip", (PyCFunction)MovieCtlObj_MCSetClip, 1, |
| "(RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)"}, |
| {"MCGetClip", (PyCFunction)MovieCtlObj_MCGetClip, 1, |
| "() -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)"}, |
| {"MCDrawBadge", (PyCFunction)MovieCtlObj_MCDrawBadge, 1, |
| "(RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)"}, |
| {"MCSetUpEditMenu", (PyCFunction)MovieCtlObj_MCSetUpEditMenu, 1, |
| "(long modifiers, MenuHandle mh) -> (ComponentResult _rv)"}, |
| {"MCGetMenuString", (PyCFunction)MovieCtlObj_MCGetMenuString, 1, |
| "(long modifiers, short item, Str255 aString) -> (ComponentResult _rv)"}, |
| {"MCPtInController", (PyCFunction)MovieCtlObj_MCPtInController, 1, |
| "(Point thePt) -> (ComponentResult _rv, Boolean inController)"}, |
| {"MCInvalidate", (PyCFunction)MovieCtlObj_MCInvalidate, 1, |
| "(WindowPtr w, RgnHandle invalidRgn) -> (ComponentResult _rv)"}, |
| {"MCAdjustCursor", (PyCFunction)MovieCtlObj_MCAdjustCursor, 1, |
| "(WindowPtr w, Point where, long modifiers) -> (ComponentResult _rv)"}, |
| {"MCGetInterfaceElement", (PyCFunction)MovieCtlObj_MCGetInterfaceElement, 1, |
| "(MCInterfaceElement whichElement, void * element) -> (ComponentResult _rv)"}, |
| {NULL, NULL, 0} |
| }; |
| |
| PyMethodChain MovieCtlObj_chain = { MovieCtlObj_methods, NULL }; |
| |
| static PyObject *MovieCtlObj_getattr(self, name) |
| MovieControllerObject *self; |
| char *name; |
| { |
| return Py_FindMethodInChain(&MovieCtlObj_chain, (PyObject *)self, name); |
| } |
| |
| #define MovieCtlObj_setattr NULL |
| |
| #define MovieCtlObj_compare NULL |
| |
| #define MovieCtlObj_repr NULL |
| |
| #define MovieCtlObj_hash NULL |
| |
| PyTypeObject MovieController_Type = { |
| PyObject_HEAD_INIT(&PyType_Type) |
| 0, /*ob_size*/ |
| "MovieController", /*tp_name*/ |
| sizeof(MovieControllerObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) MovieCtlObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc) MovieCtlObj_getattr, /*tp_getattr*/ |
| (setattrfunc) MovieCtlObj_setattr, /*tp_setattr*/ |
| (cmpfunc) MovieCtlObj_compare, /*tp_compare*/ |
| (reprfunc) MovieCtlObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) MovieCtlObj_hash, /*tp_hash*/ |
| }; |
| |
| /* ---------------- End object type MovieController ----------------- */ |
| |
| |
| /* ---------------------- Object type TimeBase ---------------------- */ |
| |
| PyTypeObject TimeBase_Type; |
| |
| #define TimeBaseObj_Check(x) ((x)->ob_type == &TimeBase_Type) |
| |
| typedef struct TimeBaseObject { |
| PyObject_HEAD |
| TimeBase ob_itself; |
| } TimeBaseObject; |
| |
| PyObject *TimeBaseObj_New(itself) |
| TimeBase itself; |
| { |
| TimeBaseObject *it; |
| if (itself == NULL) { |
| PyErr_SetString(Qt_Error,"Cannot create null TimeBase"); |
| return NULL; |
| } |
| it = PyObject_NEW(TimeBaseObject, &TimeBase_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| return (PyObject *)it; |
| } |
| TimeBaseObj_Convert(v, p_itself) |
| PyObject *v; |
| TimeBase *p_itself; |
| { |
| if (!TimeBaseObj_Check(v)) |
| { |
| PyErr_SetString(PyExc_TypeError, "TimeBase required"); |
| return 0; |
| } |
| *p_itself = ((TimeBaseObject *)v)->ob_itself; |
| return 1; |
| } |
| |
| static void TimeBaseObj_dealloc(self) |
| TimeBaseObject *self; |
| { |
| /* Cleanup of self->ob_itself goes here */ |
| PyMem_DEL(self); |
| } |
| |
| static PyObject *TimeBaseObj_DisposeTimeBase(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| DisposeTimeBase(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_GetTimeBaseTime(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| TimeScale s; |
| TimeRecord tr; |
| 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(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeRecord tr; |
| 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(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue t; |
| TimeScale s; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &t, |
| &s)) |
| return NULL; |
| SetTimeBaseValue(_self->ob_itself, |
| t, |
| s); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_GetTimeBaseRate(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Fixed _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTimeBaseRate(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildFixed, _rv); |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_SetTimeBaseRate(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Fixed r; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetFixed, &r)) |
| return NULL; |
| SetTimeBaseRate(_self->ob_itself, |
| r); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_GetTimeBaseStartTime(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| TimeScale s; |
| TimeRecord tr; |
| 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(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeRecord tr; |
| 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(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| TimeScale s; |
| TimeRecord tr; |
| 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(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeRecord tr; |
| 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(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTimeBaseFlags(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_SetTimeBaseFlags(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long timeBaseFlags; |
| if (!PyArg_ParseTuple(_args, "l", |
| &timeBaseFlags)) |
| return NULL; |
| SetTimeBaseFlags(_self->ob_itself, |
| timeBaseFlags); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_SetTimeBaseMasterTimeBase(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeBase master; |
| TimeRecord slaveZero; |
| 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(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeBase _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTimeBaseMasterTimeBase(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| TimeBaseObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_SetTimeBaseMasterClock(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Component clockMeister; |
| TimeRecord slaveZero; |
| 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(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentInstance _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTimeBaseMasterClock(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| CmpInstObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TimeBaseObj_GetTimeBaseStatus(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| TimeRecord unpinnedTime; |
| 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(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeRecord zero; |
| 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(_self, _args) |
| TimeBaseObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Fixed _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTimeBaseEffectiveRate(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildFixed, _rv); |
| return _res; |
| } |
| |
| static PyMethodDef TimeBaseObj_methods[] = { |
| {"DisposeTimeBase", (PyCFunction)TimeBaseObj_DisposeTimeBase, 1, |
| "() -> None"}, |
| {"GetTimeBaseTime", (PyCFunction)TimeBaseObj_GetTimeBaseTime, 1, |
| "(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"}, |
| {"SetTimeBaseTime", (PyCFunction)TimeBaseObj_SetTimeBaseTime, 1, |
| "(TimeRecord tr) -> None"}, |
| {"SetTimeBaseValue", (PyCFunction)TimeBaseObj_SetTimeBaseValue, 1, |
| "(TimeValue t, TimeScale s) -> None"}, |
| {"GetTimeBaseRate", (PyCFunction)TimeBaseObj_GetTimeBaseRate, 1, |
| "() -> (Fixed _rv)"}, |
| {"SetTimeBaseRate", (PyCFunction)TimeBaseObj_SetTimeBaseRate, 1, |
| "(Fixed r) -> None"}, |
| {"GetTimeBaseStartTime", (PyCFunction)TimeBaseObj_GetTimeBaseStartTime, 1, |
| "(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"}, |
| {"SetTimeBaseStartTime", (PyCFunction)TimeBaseObj_SetTimeBaseStartTime, 1, |
| "(TimeRecord tr) -> None"}, |
| {"GetTimeBaseStopTime", (PyCFunction)TimeBaseObj_GetTimeBaseStopTime, 1, |
| "(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"}, |
| {"SetTimeBaseStopTime", (PyCFunction)TimeBaseObj_SetTimeBaseStopTime, 1, |
| "(TimeRecord tr) -> None"}, |
| {"GetTimeBaseFlags", (PyCFunction)TimeBaseObj_GetTimeBaseFlags, 1, |
| "() -> (long _rv)"}, |
| {"SetTimeBaseFlags", (PyCFunction)TimeBaseObj_SetTimeBaseFlags, 1, |
| "(long timeBaseFlags) -> None"}, |
| {"SetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_SetTimeBaseMasterTimeBase, 1, |
| "(TimeBase master, TimeRecord slaveZero) -> None"}, |
| {"GetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_GetTimeBaseMasterTimeBase, 1, |
| "() -> (TimeBase _rv)"}, |
| {"SetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_SetTimeBaseMasterClock, 1, |
| "(Component clockMeister, TimeRecord slaveZero) -> None"}, |
| {"GetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_GetTimeBaseMasterClock, 1, |
| "() -> (ComponentInstance _rv)"}, |
| {"GetTimeBaseStatus", (PyCFunction)TimeBaseObj_GetTimeBaseStatus, 1, |
| "() -> (long _rv, TimeRecord unpinnedTime)"}, |
| {"SetTimeBaseZero", (PyCFunction)TimeBaseObj_SetTimeBaseZero, 1, |
| "(TimeRecord zero) -> None"}, |
| {"GetTimeBaseEffectiveRate", (PyCFunction)TimeBaseObj_GetTimeBaseEffectiveRate, 1, |
| "() -> (Fixed _rv)"}, |
| {NULL, NULL, 0} |
| }; |
| |
| PyMethodChain TimeBaseObj_chain = { TimeBaseObj_methods, NULL }; |
| |
| static PyObject *TimeBaseObj_getattr(self, name) |
| TimeBaseObject *self; |
| char *name; |
| { |
| return Py_FindMethodInChain(&TimeBaseObj_chain, (PyObject *)self, name); |
| } |
| |
| #define TimeBaseObj_setattr NULL |
| |
| #define TimeBaseObj_compare NULL |
| |
| #define TimeBaseObj_repr NULL |
| |
| #define TimeBaseObj_hash NULL |
| |
| PyTypeObject TimeBase_Type = { |
| PyObject_HEAD_INIT(&PyType_Type) |
| 0, /*ob_size*/ |
| "TimeBase", /*tp_name*/ |
| sizeof(TimeBaseObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) TimeBaseObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc) TimeBaseObj_getattr, /*tp_getattr*/ |
| (setattrfunc) TimeBaseObj_setattr, /*tp_setattr*/ |
| (cmpfunc) TimeBaseObj_compare, /*tp_compare*/ |
| (reprfunc) TimeBaseObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) TimeBaseObj_hash, /*tp_hash*/ |
| }; |
| |
| /* -------------------- End object type TimeBase -------------------- */ |
| |
| |
| /* ---------------------- Object type UserData ---------------------- */ |
| |
| PyTypeObject UserData_Type; |
| |
| #define UserDataObj_Check(x) ((x)->ob_type == &UserData_Type) |
| |
| typedef struct UserDataObject { |
| PyObject_HEAD |
| UserData ob_itself; |
| } UserDataObject; |
| |
| PyObject *UserDataObj_New(itself) |
| UserData itself; |
| { |
| UserDataObject *it; |
| if (itself == NULL) { |
| PyErr_SetString(Qt_Error,"Cannot create null UserData"); |
| return NULL; |
| } |
| it = PyObject_NEW(UserDataObject, &UserData_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| return (PyObject *)it; |
| } |
| UserDataObj_Convert(v, p_itself) |
| PyObject *v; |
| UserData *p_itself; |
| { |
| if (!UserDataObj_Check(v)) |
| { |
| PyErr_SetString(PyExc_TypeError, "UserData required"); |
| return 0; |
| } |
| *p_itself = ((UserDataObject *)v)->ob_itself; |
| return 1; |
| } |
| |
| static void UserDataObj_dealloc(self) |
| UserDataObject *self; |
| { |
| DisposeUserData(self->ob_itself); |
| PyMem_DEL(self); |
| } |
| |
| static PyObject *UserDataObj_GetUserData(_self, _args) |
| UserDataObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle data; |
| OSType udType; |
| long index; |
| if (!PyArg_ParseTuple(_args, "O&O&l", |
| ResObj_Convert, &data, |
| PyMac_GetOSType, &udType, |
| &index)) |
| return NULL; |
| _err = GetUserData(_self->ob_itself, |
| data, |
| udType, |
| index); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_AddUserData(_self, _args) |
| UserDataObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle data; |
| OSType udType; |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| ResObj_Convert, &data, |
| PyMac_GetOSType, &udType)) |
| return NULL; |
| _err = AddUserData(_self->ob_itself, |
| data, |
| udType); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_RemoveUserData(_self, _args) |
| UserDataObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| OSType udType; |
| long index; |
| if (!PyArg_ParseTuple(_args, "O&l", |
| PyMac_GetOSType, &udType, |
| &index)) |
| return NULL; |
| _err = RemoveUserData(_self->ob_itself, |
| udType, |
| index); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_CountUserDataType(_self, _args) |
| UserDataObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| OSType udType; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetOSType, &udType)) |
| return NULL; |
| _rv = CountUserDataType(_self->ob_itself, |
| udType); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_GetNextUserDataType(_self, _args) |
| UserDataObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| OSType udType; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetOSType, &udType)) |
| return NULL; |
| _rv = GetNextUserDataType(_self->ob_itself, |
| udType); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_AddUserDataText(_self, _args) |
| UserDataObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle data; |
| OSType udType; |
| long index; |
| short itlRegionTag; |
| if (!PyArg_ParseTuple(_args, "O&O&lh", |
| ResObj_Convert, &data, |
| PyMac_GetOSType, &udType, |
| &index, |
| &itlRegionTag)) |
| return NULL; |
| _err = AddUserDataText(_self->ob_itself, |
| data, |
| udType, |
| index, |
| itlRegionTag); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_GetUserDataText(_self, _args) |
| UserDataObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle data; |
| OSType udType; |
| long index; |
| short itlRegionTag; |
| if (!PyArg_ParseTuple(_args, "O&O&lh", |
| ResObj_Convert, &data, |
| PyMac_GetOSType, &udType, |
| &index, |
| &itlRegionTag)) |
| return NULL; |
| _err = GetUserDataText(_self->ob_itself, |
| data, |
| udType, |
| index, |
| itlRegionTag); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_RemoveUserDataText(_self, _args) |
| UserDataObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| OSType udType; |
| long index; |
| short itlRegionTag; |
| if (!PyArg_ParseTuple(_args, "O&lh", |
| PyMac_GetOSType, &udType, |
| &index, |
| &itlRegionTag)) |
| return NULL; |
| _err = RemoveUserDataText(_self->ob_itself, |
| udType, |
| index, |
| itlRegionTag); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *UserDataObj_PutUserDataIntoHandle(_self, _args) |
| UserDataObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle h; |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &h)) |
| return NULL; |
| _err = PutUserDataIntoHandle(_self->ob_itself, |
| h); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyMethodDef UserDataObj_methods[] = { |
| {"GetUserData", (PyCFunction)UserDataObj_GetUserData, 1, |
| "(Handle data, OSType udType, long index) -> None"}, |
| {"AddUserData", (PyCFunction)UserDataObj_AddUserData, 1, |
| "(Handle data, OSType udType) -> None"}, |
| {"RemoveUserData", (PyCFunction)UserDataObj_RemoveUserData, 1, |
| "(OSType udType, long index) -> None"}, |
| {"CountUserDataType", (PyCFunction)UserDataObj_CountUserDataType, 1, |
| "(OSType udType) -> (short _rv)"}, |
| {"GetNextUserDataType", (PyCFunction)UserDataObj_GetNextUserDataType, 1, |
| "(OSType udType) -> (long _rv)"}, |
| {"AddUserDataText", (PyCFunction)UserDataObj_AddUserDataText, 1, |
| "(Handle data, OSType udType, long index, short itlRegionTag) -> None"}, |
| {"GetUserDataText", (PyCFunction)UserDataObj_GetUserDataText, 1, |
| "(Handle data, OSType udType, long index, short itlRegionTag) -> None"}, |
| {"RemoveUserDataText", (PyCFunction)UserDataObj_RemoveUserDataText, 1, |
| "(OSType udType, long index, short itlRegionTag) -> None"}, |
| {"PutUserDataIntoHandle", (PyCFunction)UserDataObj_PutUserDataIntoHandle, 1, |
| "(Handle h) -> None"}, |
| {NULL, NULL, 0} |
| }; |
| |
| PyMethodChain UserDataObj_chain = { UserDataObj_methods, NULL }; |
| |
| static PyObject *UserDataObj_getattr(self, name) |
| UserDataObject *self; |
| char *name; |
| { |
| return Py_FindMethodInChain(&UserDataObj_chain, (PyObject *)self, name); |
| } |
| |
| #define UserDataObj_setattr NULL |
| |
| #define UserDataObj_compare NULL |
| |
| #define UserDataObj_repr NULL |
| |
| #define UserDataObj_hash NULL |
| |
| PyTypeObject UserData_Type = { |
| PyObject_HEAD_INIT(&PyType_Type) |
| 0, /*ob_size*/ |
| "UserData", /*tp_name*/ |
| sizeof(UserDataObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) UserDataObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc) UserDataObj_getattr, /*tp_getattr*/ |
| (setattrfunc) UserDataObj_setattr, /*tp_setattr*/ |
| (cmpfunc) UserDataObj_compare, /*tp_compare*/ |
| (reprfunc) UserDataObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) UserDataObj_hash, /*tp_hash*/ |
| }; |
| |
| /* -------------------- End object type UserData -------------------- */ |
| |
| |
| /* ----------------------- Object type Media ------------------------ */ |
| |
| PyTypeObject Media_Type; |
| |
| #define MediaObj_Check(x) ((x)->ob_type == &Media_Type) |
| |
| typedef struct MediaObject { |
| PyObject_HEAD |
| Media ob_itself; |
| } MediaObject; |
| |
| PyObject *MediaObj_New(itself) |
| Media itself; |
| { |
| MediaObject *it; |
| if (itself == NULL) { |
| PyErr_SetString(Qt_Error,"Cannot create null Media"); |
| return NULL; |
| } |
| it = PyObject_NEW(MediaObject, &Media_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| return (PyObject *)it; |
| } |
| MediaObj_Convert(v, p_itself) |
| PyObject *v; |
| Media *p_itself; |
| { |
| if (!MediaObj_Check(v)) |
| { |
| PyErr_SetString(PyExc_TypeError, "Media required"); |
| return 0; |
| } |
| *p_itself = ((MediaObject *)v)->ob_itself; |
| return 1; |
| } |
| |
| static void MediaObj_dealloc(self) |
| MediaObject *self; |
| { |
| DisposeTrackMedia(self->ob_itself); |
| PyMem_DEL(self); |
| } |
| |
| static PyObject *MediaObj_LoadMediaIntoRam(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue time; |
| TimeValue duration; |
| long flags; |
| if (!PyArg_ParseTuple(_args, "lll", |
| &time, |
| &duration, |
| &flags)) |
| return NULL; |
| _err = LoadMediaIntoRam(_self->ob_itself, |
| time, |
| duration, |
| flags); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaTrack(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaTrack(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaCreationTime(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| unsigned long _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaCreationTime(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaModificationTime(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| unsigned long _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaModificationTime(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaTimeScale(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeScale _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaTimeScale(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaTimeScale(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeScale timeScale; |
| if (!PyArg_ParseTuple(_args, "l", |
| &timeScale)) |
| return NULL; |
| SetMediaTimeScale(_self->ob_itself, |
| timeScale); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaDuration(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaDuration(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaLanguage(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaLanguage(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaLanguage(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short language; |
| if (!PyArg_ParseTuple(_args, "h", |
| &language)) |
| return NULL; |
| SetMediaLanguage(_self->ob_itself, |
| language); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaQuality(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaQuality(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaQuality(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short quality; |
| if (!PyArg_ParseTuple(_args, "h", |
| &quality)) |
| return NULL; |
| SetMediaQuality(_self->ob_itself, |
| quality); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaHandlerDescription(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSType mediaType; |
| Str255 creatorName; |
| OSType creatorManufacturer; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetStr255, creatorName)) |
| return NULL; |
| GetMediaHandlerDescription(_self->ob_itself, |
| &mediaType, |
| creatorName, |
| &creatorManufacturer); |
| _res = Py_BuildValue("O&O&", |
| PyMac_BuildOSType, mediaType, |
| PyMac_BuildOSType, creatorManufacturer); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaUserData(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| UserData _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaUserData(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| UserDataObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaHandler(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| MediaHandler _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaHandler(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| CmpInstObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaHandler(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| MediaHandlerComponent mH; |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpObj_Convert, &mH)) |
| return NULL; |
| _err = SetMediaHandler(_self->ob_itself, |
| mH); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_BeginMediaEdits(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = BeginMediaEdits(_self->ob_itself); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_EndMediaEdits(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = EndMediaEdits(_self->ob_itself); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaDefaultDataRefIndex(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short index; |
| if (!PyArg_ParseTuple(_args, "h", |
| &index)) |
| return NULL; |
| _err = SetMediaDefaultDataRefIndex(_self->ob_itself, |
| index); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaDataHandlerDescription(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short index; |
| OSType dhType; |
| Str255 creatorName; |
| OSType creatorManufacturer; |
| if (!PyArg_ParseTuple(_args, "hO&", |
| &index, |
| PyMac_GetStr255, creatorName)) |
| return NULL; |
| GetMediaDataHandlerDescription(_self->ob_itself, |
| index, |
| &dhType, |
| creatorName, |
| &creatorManufacturer); |
| _res = Py_BuildValue("O&O&", |
| PyMac_BuildOSType, dhType, |
| PyMac_BuildOSType, creatorManufacturer); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaDataHandler(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| DataHandler _rv; |
| short index; |
| if (!PyArg_ParseTuple(_args, "h", |
| &index)) |
| return NULL; |
| _rv = GetMediaDataHandler(_self->ob_itself, |
| index); |
| _res = Py_BuildValue("O&", |
| CmpInstObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaDataHandler(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short index; |
| DataHandlerComponent dataHandler; |
| if (!PyArg_ParseTuple(_args, "hO&", |
| &index, |
| CmpObj_Convert, &dataHandler)) |
| return NULL; |
| _err = SetMediaDataHandler(_self->ob_itself, |
| index, |
| dataHandler); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaSampleDescriptionCount(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaSampleDescriptionCount(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaSampleDescription(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long index; |
| SampleDescriptionHandle descH; |
| if (!PyArg_ParseTuple(_args, "lO&", |
| &index, |
| ResObj_Convert, &descH)) |
| return NULL; |
| GetMediaSampleDescription(_self->ob_itself, |
| index, |
| descH); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaSampleDescription(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long index; |
| SampleDescriptionHandle descH; |
| if (!PyArg_ParseTuple(_args, "lO&", |
| &index, |
| ResObj_Convert, &descH)) |
| return NULL; |
| _err = SetMediaSampleDescription(_self->ob_itself, |
| index, |
| descH); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaSampleCount(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaSampleCount(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaSyncSampleCount(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMediaSyncSampleCount(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SampleNumToMediaTime(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long logicalSampleNum; |
| TimeValue sampleTime; |
| TimeValue sampleDuration; |
| if (!PyArg_ParseTuple(_args, "l", |
| &logicalSampleNum)) |
| return NULL; |
| SampleNumToMediaTime(_self->ob_itself, |
| logicalSampleNum, |
| &sampleTime, |
| &sampleDuration); |
| _res = Py_BuildValue("ll", |
| sampleTime, |
| sampleDuration); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_MediaTimeToSampleNum(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue time; |
| long sampleNum; |
| TimeValue sampleTime; |
| TimeValue sampleDuration; |
| if (!PyArg_ParseTuple(_args, "l", |
| &time)) |
| return NULL; |
| MediaTimeToSampleNum(_self->ob_itself, |
| time, |
| &sampleNum, |
| &sampleTime, |
| &sampleDuration); |
| _res = Py_BuildValue("lll", |
| sampleNum, |
| sampleTime, |
| sampleDuration); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_AddMediaSample(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle dataIn; |
| long inOffset; |
| unsigned long size; |
| TimeValue durationPerSample; |
| SampleDescriptionHandle sampleDescriptionH; |
| long numberOfSamples; |
| short sampleFlags; |
| TimeValue sampleTime; |
| if (!PyArg_ParseTuple(_args, "O&lllO&lh", |
| ResObj_Convert, &dataIn, |
| &inOffset, |
| &size, |
| &durationPerSample, |
| ResObj_Convert, &sampleDescriptionH, |
| &numberOfSamples, |
| &sampleFlags)) |
| return NULL; |
| _err = AddMediaSample(_self->ob_itself, |
| dataIn, |
| inOffset, |
| size, |
| durationPerSample, |
| sampleDescriptionH, |
| numberOfSamples, |
| sampleFlags, |
| &sampleTime); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| sampleTime); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_AddMediaSampleReference(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long dataOffset; |
| unsigned long size; |
| TimeValue durationPerSample; |
| SampleDescriptionHandle sampleDescriptionH; |
| long numberOfSamples; |
| short sampleFlags; |
| TimeValue sampleTime; |
| if (!PyArg_ParseTuple(_args, "lllO&lh", |
| &dataOffset, |
| &size, |
| &durationPerSample, |
| ResObj_Convert, &sampleDescriptionH, |
| &numberOfSamples, |
| &sampleFlags)) |
| return NULL; |
| _err = AddMediaSampleReference(_self->ob_itself, |
| dataOffset, |
| size, |
| durationPerSample, |
| sampleDescriptionH, |
| numberOfSamples, |
| sampleFlags, |
| &sampleTime); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| sampleTime); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaSample(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle dataOut; |
| long maxSizeToGrow; |
| long size; |
| TimeValue time; |
| TimeValue sampleTime; |
| TimeValue durationPerSample; |
| SampleDescriptionHandle sampleDescriptionH; |
| long sampleDescriptionIndex; |
| long maxNumberOfSamples; |
| long numberOfSamples; |
| short sampleFlags; |
| if (!PyArg_ParseTuple(_args, "O&llO&l", |
| ResObj_Convert, &dataOut, |
| &maxSizeToGrow, |
| &time, |
| ResObj_Convert, &sampleDescriptionH, |
| &maxNumberOfSamples)) |
| return NULL; |
| _err = GetMediaSample(_self->ob_itself, |
| dataOut, |
| maxSizeToGrow, |
| &size, |
| time, |
| &sampleTime, |
| &durationPerSample, |
| sampleDescriptionH, |
| &sampleDescriptionIndex, |
| maxNumberOfSamples, |
| &numberOfSamples, |
| &sampleFlags); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("lllllh", |
| size, |
| sampleTime, |
| durationPerSample, |
| sampleDescriptionIndex, |
| numberOfSamples, |
| sampleFlags); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaSampleReference(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long dataOffset; |
| long size; |
| TimeValue time; |
| TimeValue sampleTime; |
| TimeValue durationPerSample; |
| SampleDescriptionHandle sampleDescriptionH; |
| long sampleDescriptionIndex; |
| long maxNumberOfSamples; |
| long numberOfSamples; |
| short sampleFlags; |
| if (!PyArg_ParseTuple(_args, "lO&l", |
| &time, |
| ResObj_Convert, &sampleDescriptionH, |
| &maxNumberOfSamples)) |
| return NULL; |
| _err = GetMediaSampleReference(_self->ob_itself, |
| &dataOffset, |
| &size, |
| time, |
| &sampleTime, |
| &durationPerSample, |
| sampleDescriptionH, |
| &sampleDescriptionIndex, |
| maxNumberOfSamples, |
| &numberOfSamples, |
| &sampleFlags); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("llllllh", |
| dataOffset, |
| size, |
| sampleTime, |
| durationPerSample, |
| sampleDescriptionIndex, |
| numberOfSamples, |
| sampleFlags); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaPreferredChunkSize(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long maxChunkSize; |
| if (!PyArg_ParseTuple(_args, "l", |
| &maxChunkSize)) |
| return NULL; |
| _err = SetMediaPreferredChunkSize(_self->ob_itself, |
| maxChunkSize); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaPreferredChunkSize(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long maxChunkSize; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetMediaPreferredChunkSize(_self->ob_itself, |
| &maxChunkSize); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| maxChunkSize); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaShadowSync(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long frameDiffSampleNum; |
| long syncSampleNum; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &frameDiffSampleNum, |
| &syncSampleNum)) |
| return NULL; |
| _err = SetMediaShadowSync(_self->ob_itself, |
| frameDiffSampleNum, |
| syncSampleNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaShadowSync(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long frameDiffSampleNum; |
| long syncSampleNum; |
| if (!PyArg_ParseTuple(_args, "l", |
| &frameDiffSampleNum)) |
| return NULL; |
| _err = GetMediaShadowSync(_self->ob_itself, |
| frameDiffSampleNum, |
| &syncSampleNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| syncSampleNum); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaDataSize(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| TimeValue startTime; |
| TimeValue duration; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| _rv = GetMediaDataSize(_self->ob_itself, |
| startTime, |
| duration); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaNextInterestingTime(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short interestingTimeFlags; |
| TimeValue time; |
| Fixed rate; |
| TimeValue interestingTime; |
| TimeValue interestingDuration; |
| if (!PyArg_ParseTuple(_args, "hlO&", |
| &interestingTimeFlags, |
| &time, |
| PyMac_GetFixed, &rate)) |
| return NULL; |
| GetMediaNextInterestingTime(_self->ob_itself, |
| interestingTimeFlags, |
| time, |
| rate, |
| &interestingTime, |
| &interestingDuration); |
| _res = Py_BuildValue("ll", |
| interestingTime, |
| interestingDuration); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaDataRef(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short index; |
| Handle dataRef; |
| OSType dataRefType; |
| long dataRefAttributes; |
| if (!PyArg_ParseTuple(_args, "h", |
| &index)) |
| return NULL; |
| _err = GetMediaDataRef(_self->ob_itself, |
| index, |
| &dataRef, |
| &dataRefType, |
| &dataRefAttributes); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&O&l", |
| ResObj_New, dataRef, |
| PyMac_BuildOSType, dataRefType, |
| dataRefAttributes); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaDataRef(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short index; |
| Handle dataRef; |
| OSType dataRefType; |
| if (!PyArg_ParseTuple(_args, "hO&O&", |
| &index, |
| ResObj_Convert, &dataRef, |
| PyMac_GetOSType, &dataRefType)) |
| return NULL; |
| _err = SetMediaDataRef(_self->ob_itself, |
| index, |
| dataRef, |
| dataRefType); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaDataRefAttributes(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short index; |
| long dataRefAttributes; |
| if (!PyArg_ParseTuple(_args, "hl", |
| &index, |
| &dataRefAttributes)) |
| return NULL; |
| _err = SetMediaDataRefAttributes(_self->ob_itself, |
| index, |
| dataRefAttributes); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_AddMediaDataRef(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short index; |
| Handle dataRef; |
| OSType dataRefType; |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| ResObj_Convert, &dataRef, |
| PyMac_GetOSType, &dataRefType)) |
| return NULL; |
| _err = AddMediaDataRef(_self->ob_itself, |
| &index, |
| dataRef, |
| dataRefType); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| index); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaDataRefCount(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short count; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetMediaDataRefCount(_self->ob_itself, |
| &count); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| count); |
| return _res; |
| } |
| |
| static PyObject *MediaObj_SetMediaPlayHints(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long flags; |
| long flagsMask; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &flags, |
| &flagsMask)) |
| return NULL; |
| SetMediaPlayHints(_self->ob_itself, |
| flags, |
| flagsMask); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MediaObj_GetMediaPlayHints(_self, _args) |
| MediaObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long flags; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetMediaPlayHints(_self->ob_itself, |
| &flags); |
| _res = Py_BuildValue("l", |
| flags); |
| return _res; |
| } |
| |
| static PyMethodDef MediaObj_methods[] = { |
| {"LoadMediaIntoRam", (PyCFunction)MediaObj_LoadMediaIntoRam, 1, |
| "(TimeValue time, TimeValue duration, long flags) -> None"}, |
| {"GetMediaTrack", (PyCFunction)MediaObj_GetMediaTrack, 1, |
| "() -> (Track _rv)"}, |
| {"GetMediaCreationTime", (PyCFunction)MediaObj_GetMediaCreationTime, 1, |
| "() -> (unsigned long _rv)"}, |
| {"GetMediaModificationTime", (PyCFunction)MediaObj_GetMediaModificationTime, 1, |
| "() -> (unsigned long _rv)"}, |
| {"GetMediaTimeScale", (PyCFunction)MediaObj_GetMediaTimeScale, 1, |
| "() -> (TimeScale _rv)"}, |
| {"SetMediaTimeScale", (PyCFunction)MediaObj_SetMediaTimeScale, 1, |
| "(TimeScale timeScale) -> None"}, |
| {"GetMediaDuration", (PyCFunction)MediaObj_GetMediaDuration, 1, |
| "() -> (TimeValue _rv)"}, |
| {"GetMediaLanguage", (PyCFunction)MediaObj_GetMediaLanguage, 1, |
| "() -> (short _rv)"}, |
| {"SetMediaLanguage", (PyCFunction)MediaObj_SetMediaLanguage, 1, |
| "(short language) -> None"}, |
| {"GetMediaQuality", (PyCFunction)MediaObj_GetMediaQuality, 1, |
| "() -> (short _rv)"}, |
| {"SetMediaQuality", (PyCFunction)MediaObj_SetMediaQuality, 1, |
| "(short quality) -> None"}, |
| {"GetMediaHandlerDescription", (PyCFunction)MediaObj_GetMediaHandlerDescription, 1, |
| "(Str255 creatorName) -> (OSType mediaType, OSType creatorManufacturer)"}, |
| {"GetMediaUserData", (PyCFunction)MediaObj_GetMediaUserData, 1, |
| "() -> (UserData _rv)"}, |
| {"GetMediaHandler", (PyCFunction)MediaObj_GetMediaHandler, 1, |
| "() -> (MediaHandler _rv)"}, |
| {"SetMediaHandler", (PyCFunction)MediaObj_SetMediaHandler, 1, |
| "(MediaHandlerComponent mH) -> None"}, |
| {"BeginMediaEdits", (PyCFunction)MediaObj_BeginMediaEdits, 1, |
| "() -> None"}, |
| {"EndMediaEdits", (PyCFunction)MediaObj_EndMediaEdits, 1, |
| "() -> None"}, |
| {"SetMediaDefaultDataRefIndex", (PyCFunction)MediaObj_SetMediaDefaultDataRefIndex, 1, |
| "(short index) -> None"}, |
| {"GetMediaDataHandlerDescription", (PyCFunction)MediaObj_GetMediaDataHandlerDescription, 1, |
| "(short index, Str255 creatorName) -> (OSType dhType, OSType creatorManufacturer)"}, |
| {"GetMediaDataHandler", (PyCFunction)MediaObj_GetMediaDataHandler, 1, |
| "(short index) -> (DataHandler _rv)"}, |
| {"SetMediaDataHandler", (PyCFunction)MediaObj_SetMediaDataHandler, 1, |
| "(short index, DataHandlerComponent dataHandler) -> None"}, |
| {"GetMediaSampleDescriptionCount", (PyCFunction)MediaObj_GetMediaSampleDescriptionCount, 1, |
| "() -> (long _rv)"}, |
| {"GetMediaSampleDescription", (PyCFunction)MediaObj_GetMediaSampleDescription, 1, |
| "(long index, SampleDescriptionHandle descH) -> None"}, |
| {"SetMediaSampleDescription", (PyCFunction)MediaObj_SetMediaSampleDescription, 1, |
| "(long index, SampleDescriptionHandle descH) -> None"}, |
| {"GetMediaSampleCount", (PyCFunction)MediaObj_GetMediaSampleCount, 1, |
| "() -> (long _rv)"}, |
| {"GetMediaSyncSampleCount", (PyCFunction)MediaObj_GetMediaSyncSampleCount, 1, |
| "() -> (long _rv)"}, |
| {"SampleNumToMediaTime", (PyCFunction)MediaObj_SampleNumToMediaTime, 1, |
| "(long logicalSampleNum) -> (TimeValue sampleTime, TimeValue sampleDuration)"}, |
| {"MediaTimeToSampleNum", (PyCFunction)MediaObj_MediaTimeToSampleNum, 1, |
| "(TimeValue time) -> (long sampleNum, TimeValue sampleTime, TimeValue sampleDuration)"}, |
| {"AddMediaSample", (PyCFunction)MediaObj_AddMediaSample, 1, |
| "(Handle dataIn, long inOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)"}, |
| {"AddMediaSampleReference", (PyCFunction)MediaObj_AddMediaSampleReference, 1, |
| "(long dataOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)"}, |
| {"GetMediaSample", (PyCFunction)MediaObj_GetMediaSample, 1, |
| "(Handle dataOut, long maxSizeToGrow, TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)"}, |
| {"GetMediaSampleReference", (PyCFunction)MediaObj_GetMediaSampleReference, 1, |
| "(TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long dataOffset, long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)"}, |
| {"SetMediaPreferredChunkSize", (PyCFunction)MediaObj_SetMediaPreferredChunkSize, 1, |
| "(long maxChunkSize) -> None"}, |
| {"GetMediaPreferredChunkSize", (PyCFunction)MediaObj_GetMediaPreferredChunkSize, 1, |
| "() -> (long maxChunkSize)"}, |
| {"SetMediaShadowSync", (PyCFunction)MediaObj_SetMediaShadowSync, 1, |
| "(long frameDiffSampleNum, long syncSampleNum) -> None"}, |
| {"GetMediaShadowSync", (PyCFunction)MediaObj_GetMediaShadowSync, 1, |
| "(long frameDiffSampleNum) -> (long syncSampleNum)"}, |
| {"GetMediaDataSize", (PyCFunction)MediaObj_GetMediaDataSize, 1, |
| "(TimeValue startTime, TimeValue duration) -> (long _rv)"}, |
| {"GetMediaNextInterestingTime", (PyCFunction)MediaObj_GetMediaNextInterestingTime, 1, |
| "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"}, |
| {"GetMediaDataRef", (PyCFunction)MediaObj_GetMediaDataRef, 1, |
| "(short index) -> (Handle dataRef, OSType dataRefType, long dataRefAttributes)"}, |
| {"SetMediaDataRef", (PyCFunction)MediaObj_SetMediaDataRef, 1, |
| "(short index, Handle dataRef, OSType dataRefType) -> None"}, |
| {"SetMediaDataRefAttributes", (PyCFunction)MediaObj_SetMediaDataRefAttributes, 1, |
| "(short index, long dataRefAttributes) -> None"}, |
| {"AddMediaDataRef", (PyCFunction)MediaObj_AddMediaDataRef, 1, |
| "(Handle dataRef, OSType dataRefType) -> (short index)"}, |
| {"GetMediaDataRefCount", (PyCFunction)MediaObj_GetMediaDataRefCount, 1, |
| "() -> (short count)"}, |
| {"SetMediaPlayHints", (PyCFunction)MediaObj_SetMediaPlayHints, 1, |
| "(long flags, long flagsMask) -> None"}, |
| {"GetMediaPlayHints", (PyCFunction)MediaObj_GetMediaPlayHints, 1, |
| "() -> (long flags)"}, |
| {NULL, NULL, 0} |
| }; |
| |
| PyMethodChain MediaObj_chain = { MediaObj_methods, NULL }; |
| |
| static PyObject *MediaObj_getattr(self, name) |
| MediaObject *self; |
| char *name; |
| { |
| return Py_FindMethodInChain(&MediaObj_chain, (PyObject *)self, name); |
| } |
| |
| #define MediaObj_setattr NULL |
| |
| #define MediaObj_compare NULL |
| |
| #define MediaObj_repr NULL |
| |
| #define MediaObj_hash NULL |
| |
| PyTypeObject Media_Type = { |
| PyObject_HEAD_INIT(&PyType_Type) |
| 0, /*ob_size*/ |
| "Media", /*tp_name*/ |
| sizeof(MediaObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) MediaObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc) MediaObj_getattr, /*tp_getattr*/ |
| (setattrfunc) MediaObj_setattr, /*tp_setattr*/ |
| (cmpfunc) MediaObj_compare, /*tp_compare*/ |
| (reprfunc) MediaObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) MediaObj_hash, /*tp_hash*/ |
| }; |
| |
| /* --------------------- End object type Media ---------------------- */ |
| |
| |
| /* ----------------------- Object type Track ------------------------ */ |
| |
| PyTypeObject Track_Type; |
| |
| #define TrackObj_Check(x) ((x)->ob_type == &Track_Type) |
| |
| typedef struct TrackObject { |
| PyObject_HEAD |
| Track ob_itself; |
| } TrackObject; |
| |
| PyObject *TrackObj_New(itself) |
| Track itself; |
| { |
| TrackObject *it; |
| if (itself == NULL) { |
| PyErr_SetString(Qt_Error,"Cannot create null Track"); |
| return NULL; |
| } |
| it = PyObject_NEW(TrackObject, &Track_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| return (PyObject *)it; |
| } |
| TrackObj_Convert(v, p_itself) |
| PyObject *v; |
| Track *p_itself; |
| { |
| if (!TrackObj_Check(v)) |
| { |
| PyErr_SetString(PyExc_TypeError, "Track required"); |
| return 0; |
| } |
| *p_itself = ((TrackObject *)v)->ob_itself; |
| return 1; |
| } |
| |
| static void TrackObj_dealloc(self) |
| TrackObject *self; |
| { |
| DisposeMovieTrack(self->ob_itself); |
| PyMem_DEL(self); |
| } |
| |
| static PyObject *TrackObj_LoadTrackIntoRam(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue time; |
| TimeValue duration; |
| long flags; |
| if (!PyArg_ParseTuple(_args, "lll", |
| &time, |
| &duration, |
| &flags)) |
| return NULL; |
| _err = LoadTrackIntoRam(_self->ob_itself, |
| time, |
| duration, |
| flags); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackPict(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| PicHandle _rv; |
| TimeValue time; |
| if (!PyArg_ParseTuple(_args, "l", |
| &time)) |
| return NULL; |
| _rv = GetTrackPict(_self->ob_itself, |
| time); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackClipRgn(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackClipRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackClipRgn(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle theClip; |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &theClip)) |
| return NULL; |
| SetTrackClipRgn(_self->ob_itself, |
| theClip); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackDisplayBoundsRgn(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackDisplayBoundsRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackMovieBoundsRgn(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackMovieBoundsRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackBoundsRgn(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackBoundsRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackMatte(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| PixMapHandle _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackMatte(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackMatte(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| PixMapHandle theMatte; |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &theMatte)) |
| return NULL; |
| SetTrackMatte(_self->ob_itself, |
| theMatte); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackID(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackID(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackMovie(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackMovie(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackCreationTime(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| unsigned long _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackCreationTime(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackModificationTime(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| unsigned long _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackModificationTime(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackEnabled(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackEnabled(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackEnabled(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Boolean isEnabled; |
| if (!PyArg_ParseTuple(_args, "b", |
| &isEnabled)) |
| return NULL; |
| SetTrackEnabled(_self->ob_itself, |
| isEnabled); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackUsage(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackUsage(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackUsage(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long usage; |
| if (!PyArg_ParseTuple(_args, "l", |
| &usage)) |
| return NULL; |
| SetTrackUsage(_self->ob_itself, |
| usage); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackDuration(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackDuration(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackOffset(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackOffset(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackOffset(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue movieOffsetTime; |
| if (!PyArg_ParseTuple(_args, "l", |
| &movieOffsetTime)) |
| return NULL; |
| SetTrackOffset(_self->ob_itself, |
| movieOffsetTime); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackLayer(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackLayer(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackLayer(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short layer; |
| if (!PyArg_ParseTuple(_args, "h", |
| &layer)) |
| return NULL; |
| SetTrackLayer(_self->ob_itself, |
| layer); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackAlternate(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackAlternate(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackAlternate(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Track alternateT; |
| if (!PyArg_ParseTuple(_args, "O&", |
| TrackObj_Convert, &alternateT)) |
| return NULL; |
| SetTrackAlternate(_self->ob_itself, |
| alternateT); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackVolume(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackVolume(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackVolume(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short volume; |
| if (!PyArg_ParseTuple(_args, "h", |
| &volume)) |
| return NULL; |
| SetTrackVolume(_self->ob_itself, |
| volume); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackDimensions(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Fixed width; |
| Fixed height; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetTrackDimensions(_self->ob_itself, |
| &width, |
| &height); |
| _res = Py_BuildValue("O&O&", |
| PyMac_BuildFixed, width, |
| PyMac_BuildFixed, height); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackDimensions(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Fixed width; |
| Fixed height; |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| PyMac_GetFixed, &width, |
| PyMac_GetFixed, &height)) |
| return NULL; |
| SetTrackDimensions(_self->ob_itself, |
| width, |
| height); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackUserData(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| UserData _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackUserData(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| UserDataObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackSoundLocalizationSettings(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle settings; |
| 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(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle settings; |
| 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(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Media _rv; |
| OSType mediaType; |
| TimeScale timeScale; |
| Handle dataRef; |
| OSType dataRefType; |
| if (!PyArg_ParseTuple(_args, "O&lO&O&", |
| PyMac_GetOSType, &mediaType, |
| &timeScale, |
| ResObj_Convert, &dataRef, |
| PyMac_GetOSType, &dataRefType)) |
| return NULL; |
| _rv = NewTrackMedia(_self->ob_itself, |
| mediaType, |
| timeScale, |
| dataRef, |
| dataRefType); |
| _res = Py_BuildValue("O&", |
| MediaObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackMedia(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Media _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackMedia(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| MediaObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_InsertMediaIntoTrack(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue trackStart; |
| TimeValue mediaTime; |
| TimeValue mediaDuration; |
| Fixed mediaRate; |
| if (!PyArg_ParseTuple(_args, "lllO&", |
| &trackStart, |
| &mediaTime, |
| &mediaDuration, |
| PyMac_GetFixed, &mediaRate)) |
| return NULL; |
| _err = InsertMediaIntoTrack(_self->ob_itself, |
| trackStart, |
| mediaTime, |
| mediaDuration, |
| mediaRate); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_InsertTrackSegment(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Track dstTrack; |
| TimeValue srcIn; |
| TimeValue srcDuration; |
| TimeValue dstIn; |
| if (!PyArg_ParseTuple(_args, "O&lll", |
| TrackObj_Convert, &dstTrack, |
| &srcIn, |
| &srcDuration, |
| &dstIn)) |
| return NULL; |
| _err = InsertTrackSegment(_self->ob_itself, |
| dstTrack, |
| srcIn, |
| srcDuration, |
| dstIn); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_InsertEmptyTrackSegment(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue dstIn; |
| TimeValue dstDuration; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &dstIn, |
| &dstDuration)) |
| return NULL; |
| _err = InsertEmptyTrackSegment(_self->ob_itself, |
| dstIn, |
| dstDuration); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_DeleteTrackSegment(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue startTime; |
| TimeValue duration; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| _err = DeleteTrackSegment(_self->ob_itself, |
| startTime, |
| duration); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_ScaleTrackSegment(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue startTime; |
| TimeValue oldDuration; |
| TimeValue newDuration; |
| if (!PyArg_ParseTuple(_args, "lll", |
| &startTime, |
| &oldDuration, |
| &newDuration)) |
| return NULL; |
| _err = ScaleTrackSegment(_self->ob_itself, |
| startTime, |
| oldDuration, |
| newDuration); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_IsScrapMovie(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Component _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = IsScrapMovie(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| CmpObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_CopyTrackSettings(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Track dstTrack; |
| if (!PyArg_ParseTuple(_args, "O&", |
| TrackObj_Convert, &dstTrack)) |
| return NULL; |
| _err = CopyTrackSettings(_self->ob_itself, |
| dstTrack); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_AddEmptyTrackToMovie(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie dstMovie; |
| Handle dataRef; |
| OSType dataRefType; |
| Track dstTrack; |
| if (!PyArg_ParseTuple(_args, "O&O&O&", |
| MovieObj_Convert, &dstMovie, |
| ResObj_Convert, &dataRef, |
| PyMac_GetOSType, &dataRefType)) |
| return NULL; |
| _err = AddEmptyTrackToMovie(_self->ob_itself, |
| dstMovie, |
| dataRef, |
| dataRefType, |
| &dstTrack); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, dstTrack); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_AddTrackReference(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Track refTrack; |
| OSType refType; |
| long addedIndex; |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| TrackObj_Convert, &refTrack, |
| PyMac_GetOSType, &refType)) |
| return NULL; |
| _err = AddTrackReference(_self->ob_itself, |
| refTrack, |
| refType, |
| &addedIndex); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| addedIndex); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_DeleteTrackReference(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| OSType refType; |
| long index; |
| if (!PyArg_ParseTuple(_args, "O&l", |
| PyMac_GetOSType, &refType, |
| &index)) |
| return NULL; |
| _err = DeleteTrackReference(_self->ob_itself, |
| refType, |
| index); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackReference(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Track refTrack; |
| OSType refType; |
| long index; |
| if (!PyArg_ParseTuple(_args, "O&O&l", |
| TrackObj_Convert, &refTrack, |
| PyMac_GetOSType, &refType, |
| &index)) |
| return NULL; |
| _err = SetTrackReference(_self->ob_itself, |
| refTrack, |
| refType, |
| index); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackReference(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| OSType refType; |
| long index; |
| if (!PyArg_ParseTuple(_args, "O&l", |
| PyMac_GetOSType, &refType, |
| &index)) |
| return NULL; |
| _rv = GetTrackReference(_self->ob_itself, |
| refType, |
| index); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetNextTrackReferenceType(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSType _rv; |
| OSType refType; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetOSType, &refType)) |
| return NULL; |
| _rv = GetNextTrackReferenceType(_self->ob_itself, |
| refType); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildOSType, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackReferenceCount(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| OSType refType; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetOSType, &refType)) |
| return NULL; |
| _rv = GetTrackReferenceCount(_self->ob_itself, |
| refType); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackEditRate(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Fixed _rv; |
| TimeValue atTime; |
| if (!PyArg_ParseTuple(_args, "l", |
| &atTime)) |
| return NULL; |
| _rv = GetTrackEditRate(_self->ob_itself, |
| atTime); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildFixed, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackDataSize(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| TimeValue startTime; |
| TimeValue duration; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| _rv = GetTrackDataSize(_self->ob_itself, |
| startTime, |
| duration); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_PtInTrack(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| Point pt; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetPoint, &pt)) |
| return NULL; |
| _rv = PtInTrack(_self->ob_itself, |
| pt); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackNextInterestingTime(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short interestingTimeFlags; |
| TimeValue time; |
| Fixed rate; |
| TimeValue interestingTime; |
| TimeValue interestingDuration; |
| if (!PyArg_ParseTuple(_args, "hlO&", |
| &interestingTimeFlags, |
| &time, |
| PyMac_GetFixed, &rate)) |
| return NULL; |
| GetTrackNextInterestingTime(_self->ob_itself, |
| interestingTimeFlags, |
| time, |
| rate, |
| &interestingTime, |
| &interestingDuration); |
| _res = Py_BuildValue("ll", |
| interestingTime, |
| interestingDuration); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackSegmentDisplayBoundsRgn(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| TimeValue time; |
| TimeValue duration; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &time, |
| &duration)) |
| return NULL; |
| _rv = GetTrackSegmentDisplayBoundsRgn(_self->ob_itself, |
| time, |
| duration); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackStatus(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetTrackStatus(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *TrackObj_SetTrackLoadSettings(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue preloadTime; |
| TimeValue preloadDuration; |
| long preloadFlags; |
| long defaultHints; |
| if (!PyArg_ParseTuple(_args, "llll", |
| &preloadTime, |
| &preloadDuration, |
| &preloadFlags, |
| &defaultHints)) |
| return NULL; |
| SetTrackLoadSettings(_self->ob_itself, |
| preloadTime, |
| preloadDuration, |
| preloadFlags, |
| defaultHints); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *TrackObj_GetTrackLoadSettings(_self, _args) |
| TrackObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue preloadTime; |
| TimeValue preloadDuration; |
| long preloadFlags; |
| long defaultHints; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetTrackLoadSettings(_self->ob_itself, |
| &preloadTime, |
| &preloadDuration, |
| &preloadFlags, |
| &defaultHints); |
| _res = Py_BuildValue("llll", |
| preloadTime, |
| preloadDuration, |
| preloadFlags, |
| defaultHints); |
| return _res; |
| } |
| |
| static PyMethodDef TrackObj_methods[] = { |
| {"LoadTrackIntoRam", (PyCFunction)TrackObj_LoadTrackIntoRam, 1, |
| "(TimeValue time, TimeValue duration, long flags) -> None"}, |
| {"GetTrackPict", (PyCFunction)TrackObj_GetTrackPict, 1, |
| "(TimeValue time) -> (PicHandle _rv)"}, |
| {"GetTrackClipRgn", (PyCFunction)TrackObj_GetTrackClipRgn, 1, |
| "() -> (RgnHandle _rv)"}, |
| {"SetTrackClipRgn", (PyCFunction)TrackObj_SetTrackClipRgn, 1, |
| "(RgnHandle theClip) -> None"}, |
| {"GetTrackDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackDisplayBoundsRgn, 1, |
| "() -> (RgnHandle _rv)"}, |
| {"GetTrackMovieBoundsRgn", (PyCFunction)TrackObj_GetTrackMovieBoundsRgn, 1, |
| "() -> (RgnHandle _rv)"}, |
| {"GetTrackBoundsRgn", (PyCFunction)TrackObj_GetTrackBoundsRgn, 1, |
| "() -> (RgnHandle _rv)"}, |
| {"GetTrackMatte", (PyCFunction)TrackObj_GetTrackMatte, 1, |
| "() -> (PixMapHandle _rv)"}, |
| {"SetTrackMatte", (PyCFunction)TrackObj_SetTrackMatte, 1, |
| "(PixMapHandle theMatte) -> None"}, |
| {"GetTrackID", (PyCFunction)TrackObj_GetTrackID, 1, |
| "() -> (long _rv)"}, |
| {"GetTrackMovie", (PyCFunction)TrackObj_GetTrackMovie, 1, |
| "() -> (Movie _rv)"}, |
| {"GetTrackCreationTime", (PyCFunction)TrackObj_GetTrackCreationTime, 1, |
| "() -> (unsigned long _rv)"}, |
| {"GetTrackModificationTime", (PyCFunction)TrackObj_GetTrackModificationTime, 1, |
| "() -> (unsigned long _rv)"}, |
| {"GetTrackEnabled", (PyCFunction)TrackObj_GetTrackEnabled, 1, |
| "() -> (Boolean _rv)"}, |
| {"SetTrackEnabled", (PyCFunction)TrackObj_SetTrackEnabled, 1, |
| "(Boolean isEnabled) -> None"}, |
| {"GetTrackUsage", (PyCFunction)TrackObj_GetTrackUsage, 1, |
| "() -> (long _rv)"}, |
| {"SetTrackUsage", (PyCFunction)TrackObj_SetTrackUsage, 1, |
| "(long usage) -> None"}, |
| {"GetTrackDuration", (PyCFunction)TrackObj_GetTrackDuration, 1, |
| "() -> (TimeValue _rv)"}, |
| {"GetTrackOffset", (PyCFunction)TrackObj_GetTrackOffset, 1, |
| "() -> (TimeValue _rv)"}, |
| {"SetTrackOffset", (PyCFunction)TrackObj_SetTrackOffset, 1, |
| "(TimeValue movieOffsetTime) -> None"}, |
| {"GetTrackLayer", (PyCFunction)TrackObj_GetTrackLayer, 1, |
| "() -> (short _rv)"}, |
| {"SetTrackLayer", (PyCFunction)TrackObj_SetTrackLayer, 1, |
| "(short layer) -> None"}, |
| {"GetTrackAlternate", (PyCFunction)TrackObj_GetTrackAlternate, 1, |
| "() -> (Track _rv)"}, |
| {"SetTrackAlternate", (PyCFunction)TrackObj_SetTrackAlternate, 1, |
| "(Track alternateT) -> None"}, |
| {"GetTrackVolume", (PyCFunction)TrackObj_GetTrackVolume, 1, |
| "() -> (short _rv)"}, |
| {"SetTrackVolume", (PyCFunction)TrackObj_SetTrackVolume, 1, |
| "(short volume) -> None"}, |
| {"GetTrackDimensions", (PyCFunction)TrackObj_GetTrackDimensions, 1, |
| "() -> (Fixed width, Fixed height)"}, |
| {"SetTrackDimensions", (PyCFunction)TrackObj_SetTrackDimensions, 1, |
| "(Fixed width, Fixed height) -> None"}, |
| {"GetTrackUserData", (PyCFunction)TrackObj_GetTrackUserData, 1, |
| "() -> (UserData _rv)"}, |
| {"GetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_GetTrackSoundLocalizationSettings, 1, |
| "() -> (Handle settings)"}, |
| {"SetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_SetTrackSoundLocalizationSettings, 1, |
| "(Handle settings) -> None"}, |
| {"NewTrackMedia", (PyCFunction)TrackObj_NewTrackMedia, 1, |
| "(OSType mediaType, TimeScale timeScale, Handle dataRef, OSType dataRefType) -> (Media _rv)"}, |
| {"GetTrackMedia", (PyCFunction)TrackObj_GetTrackMedia, 1, |
| "() -> (Media _rv)"}, |
| {"InsertMediaIntoTrack", (PyCFunction)TrackObj_InsertMediaIntoTrack, 1, |
| "(TimeValue trackStart, TimeValue mediaTime, TimeValue mediaDuration, Fixed mediaRate) -> None"}, |
| {"InsertTrackSegment", (PyCFunction)TrackObj_InsertTrackSegment, 1, |
| "(Track dstTrack, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None"}, |
| {"InsertEmptyTrackSegment", (PyCFunction)TrackObj_InsertEmptyTrackSegment, 1, |
| "(TimeValue dstIn, TimeValue dstDuration) -> None"}, |
| {"DeleteTrackSegment", (PyCFunction)TrackObj_DeleteTrackSegment, 1, |
| "(TimeValue startTime, TimeValue duration) -> None"}, |
| {"ScaleTrackSegment", (PyCFunction)TrackObj_ScaleTrackSegment, 1, |
| "(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None"}, |
| {"IsScrapMovie", (PyCFunction)TrackObj_IsScrapMovie, 1, |
| "() -> (Component _rv)"}, |
| {"CopyTrackSettings", (PyCFunction)TrackObj_CopyTrackSettings, 1, |
| "(Track dstTrack) -> None"}, |
| {"AddEmptyTrackToMovie", (PyCFunction)TrackObj_AddEmptyTrackToMovie, 1, |
| "(Movie dstMovie, Handle dataRef, OSType dataRefType) -> (Track dstTrack)"}, |
| {"AddTrackReference", (PyCFunction)TrackObj_AddTrackReference, 1, |
| "(Track refTrack, OSType refType) -> (long addedIndex)"}, |
| {"DeleteTrackReference", (PyCFunction)TrackObj_DeleteTrackReference, 1, |
| "(OSType refType, long index) -> None"}, |
| {"SetTrackReference", (PyCFunction)TrackObj_SetTrackReference, 1, |
| "(Track refTrack, OSType refType, long index) -> None"}, |
| {"GetTrackReference", (PyCFunction)TrackObj_GetTrackReference, 1, |
| "(OSType refType, long index) -> (Track _rv)"}, |
| {"GetNextTrackReferenceType", (PyCFunction)TrackObj_GetNextTrackReferenceType, 1, |
| "(OSType refType) -> (OSType _rv)"}, |
| {"GetTrackReferenceCount", (PyCFunction)TrackObj_GetTrackReferenceCount, 1, |
| "(OSType refType) -> (long _rv)"}, |
| {"GetTrackEditRate", (PyCFunction)TrackObj_GetTrackEditRate, 1, |
| "(TimeValue atTime) -> (Fixed _rv)"}, |
| {"GetTrackDataSize", (PyCFunction)TrackObj_GetTrackDataSize, 1, |
| "(TimeValue startTime, TimeValue duration) -> (long _rv)"}, |
| {"PtInTrack", (PyCFunction)TrackObj_PtInTrack, 1, |
| "(Point pt) -> (Boolean _rv)"}, |
| {"GetTrackNextInterestingTime", (PyCFunction)TrackObj_GetTrackNextInterestingTime, 1, |
| "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"}, |
| {"GetTrackSegmentDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackSegmentDisplayBoundsRgn, 1, |
| "(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"}, |
| {"GetTrackStatus", (PyCFunction)TrackObj_GetTrackStatus, 1, |
| "() -> (ComponentResult _rv)"}, |
| {"SetTrackLoadSettings", (PyCFunction)TrackObj_SetTrackLoadSettings, 1, |
| "(TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints) -> None"}, |
| {"GetTrackLoadSettings", (PyCFunction)TrackObj_GetTrackLoadSettings, 1, |
| "() -> (TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints)"}, |
| {NULL, NULL, 0} |
| }; |
| |
| PyMethodChain TrackObj_chain = { TrackObj_methods, NULL }; |
| |
| static PyObject *TrackObj_getattr(self, name) |
| TrackObject *self; |
| char *name; |
| { |
| return Py_FindMethodInChain(&TrackObj_chain, (PyObject *)self, name); |
| } |
| |
| #define TrackObj_setattr NULL |
| |
| #define TrackObj_compare NULL |
| |
| #define TrackObj_repr NULL |
| |
| #define TrackObj_hash NULL |
| |
| PyTypeObject Track_Type = { |
| PyObject_HEAD_INIT(&PyType_Type) |
| 0, /*ob_size*/ |
| "Track", /*tp_name*/ |
| sizeof(TrackObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) TrackObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc) TrackObj_getattr, /*tp_getattr*/ |
| (setattrfunc) TrackObj_setattr, /*tp_setattr*/ |
| (cmpfunc) TrackObj_compare, /*tp_compare*/ |
| (reprfunc) TrackObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) TrackObj_hash, /*tp_hash*/ |
| }; |
| |
| /* --------------------- End object type Track ---------------------- */ |
| |
| |
| /* ----------------------- Object type Movie ------------------------ */ |
| |
| PyTypeObject Movie_Type; |
| |
| #define MovieObj_Check(x) ((x)->ob_type == &Movie_Type) |
| |
| typedef struct MovieObject { |
| PyObject_HEAD |
| Movie ob_itself; |
| } MovieObject; |
| |
| PyObject *MovieObj_New(itself) |
| Movie itself; |
| { |
| MovieObject *it; |
| if (itself == NULL) { |
| PyErr_SetString(Qt_Error,"Cannot create null Movie"); |
| return NULL; |
| } |
| it = PyObject_NEW(MovieObject, &Movie_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| return (PyObject *)it; |
| } |
| MovieObj_Convert(v, p_itself) |
| PyObject *v; |
| Movie *p_itself; |
| { |
| if (!MovieObj_Check(v)) |
| { |
| PyErr_SetString(PyExc_TypeError, "Movie required"); |
| return 0; |
| } |
| *p_itself = ((MovieObject *)v)->ob_itself; |
| return 1; |
| } |
| |
| static void MovieObj_dealloc(self) |
| MovieObject *self; |
| { |
| DisposeMovie(self->ob_itself); |
| PyMem_DEL(self); |
| } |
| |
| static PyObject *MovieObj_MoviesTask(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long maxMilliSecToUse; |
| if (!PyArg_ParseTuple(_args, "l", |
| &maxMilliSecToUse)) |
| return NULL; |
| MoviesTask(_self->ob_itself, |
| maxMilliSecToUse); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PrerollMovie(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue time; |
| Fixed Rate; |
| if (!PyArg_ParseTuple(_args, "lO&", |
| &time, |
| PyMac_GetFixed, &Rate)) |
| return NULL; |
| _err = PrerollMovie(_self->ob_itself, |
| time, |
| Rate); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_LoadMovieIntoRam(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue time; |
| TimeValue duration; |
| long flags; |
| if (!PyArg_ParseTuple(_args, "lll", |
| &time, |
| &duration, |
| &flags)) |
| return NULL; |
| _err = LoadMovieIntoRam(_self->ob_itself, |
| time, |
| duration, |
| flags); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieActive(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Boolean active; |
| if (!PyArg_ParseTuple(_args, "b", |
| &active)) |
| return NULL; |
| SetMovieActive(_self->ob_itself, |
| active); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieActive(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieActive(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_StartMovie(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| StartMovie(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_StopMovie(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| StopMovie(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GoToBeginningOfMovie(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GoToBeginningOfMovie(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GoToEndOfMovie(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GoToEndOfMovie(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_IsMovieDone(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = IsMovieDone(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMoviePreviewMode(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMoviePreviewMode(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMoviePreviewMode(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Boolean usePreview; |
| if (!PyArg_ParseTuple(_args, "b", |
| &usePreview)) |
| return NULL; |
| SetMoviePreviewMode(_self->ob_itself, |
| usePreview); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_ShowMoviePoster(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| ShowMoviePoster(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieTimeBase(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeBase _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieTimeBase(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| TimeBaseObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieMasterTimeBase(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeBase tb; |
| TimeRecord slaveZero; |
| 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(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Component clockMeister; |
| TimeRecord slaveZero; |
| 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(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| CGrafPtr port; |
| GDHandle gdh; |
| 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(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| CGrafPtr port; |
| GDHandle gdh; |
| 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(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Rect naturalBounds; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetMovieNaturalBoundsRect(_self->ob_itself, |
| &naturalBounds); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildRect, &naturalBounds); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetNextTrackForCompositing(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| Track theTrack; |
| if (!PyArg_ParseTuple(_args, "O&", |
| TrackObj_Convert, &theTrack)) |
| return NULL; |
| _rv = GetNextTrackForCompositing(_self->ob_itself, |
| theTrack); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetPrevTrackForCompositing(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| Track theTrack; |
| if (!PyArg_ParseTuple(_args, "O&", |
| TrackObj_Convert, &theTrack)) |
| return NULL; |
| _rv = GetPrevTrackForCompositing(_self->ob_itself, |
| theTrack); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMoviePict(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| PicHandle _rv; |
| TimeValue time; |
| if (!PyArg_ParseTuple(_args, "l", |
| &time)) |
| return NULL; |
| _rv = GetMoviePict(_self->ob_itself, |
| time); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMoviePosterPict(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| PicHandle _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMoviePosterPict(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_UpdateMovie(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = UpdateMovie(_self->ob_itself); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_InvalidateMovieRegion(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| RgnHandle invalidRgn; |
| 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(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Rect boxRect; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetMovieBox(_self->ob_itself, |
| &boxRect); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildRect, &boxRect); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieBox(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Rect boxRect; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetRect, &boxRect)) |
| return NULL; |
| SetMovieBox(_self->ob_itself, |
| &boxRect); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieDisplayClipRgn(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieDisplayClipRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieDisplayClipRgn(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle theClip; |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &theClip)) |
| return NULL; |
| SetMovieDisplayClipRgn(_self->ob_itself, |
| theClip); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieClipRgn(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieClipRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieClipRgn(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle theClip; |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &theClip)) |
| return NULL; |
| SetMovieClipRgn(_self->ob_itself, |
| theClip); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieDisplayBoundsRgn(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieDisplayBoundsRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieBoundsRgn(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieBoundsRgn(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PutMovieIntoHandle(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle publicMovie; |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &publicMovie)) |
| return NULL; |
| _err = PutMovieIntoHandle(_self->ob_itself, |
| publicMovie); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PutMovieIntoDataFork(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short fRefNum; |
| long offset; |
| long maxSize; |
| if (!PyArg_ParseTuple(_args, "hll", |
| &fRefNum, |
| &offset, |
| &maxSize)) |
| return NULL; |
| _err = PutMovieIntoDataFork(_self->ob_itself, |
| fRefNum, |
| offset, |
| maxSize); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieCreationTime(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| unsigned long _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieCreationTime(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieModificationTime(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| unsigned long _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieModificationTime(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieTimeScale(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeScale _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieTimeScale(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieTimeScale(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeScale timeScale; |
| if (!PyArg_ParseTuple(_args, "l", |
| &timeScale)) |
| return NULL; |
| SetMovieTimeScale(_self->ob_itself, |
| timeScale); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieDuration(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieDuration(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieRate(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Fixed _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieRate(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildFixed, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieRate(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Fixed rate; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetFixed, &rate)) |
| return NULL; |
| SetMovieRate(_self->ob_itself, |
| rate); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMoviePreferredRate(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Fixed _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMoviePreferredRate(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildFixed, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMoviePreferredRate(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Fixed rate; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetFixed, &rate)) |
| return NULL; |
| SetMoviePreferredRate(_self->ob_itself, |
| rate); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMoviePreferredVolume(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMoviePreferredVolume(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMoviePreferredVolume(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short volume; |
| if (!PyArg_ParseTuple(_args, "h", |
| &volume)) |
| return NULL; |
| SetMoviePreferredVolume(_self->ob_itself, |
| volume); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieVolume(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieVolume(_self->ob_itself); |
| _res = Py_BuildValue("h", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieVolume(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short volume; |
| if (!PyArg_ParseTuple(_args, "h", |
| &volume)) |
| return NULL; |
| SetMovieVolume(_self->ob_itself, |
| volume); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMoviePreviewTime(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue previewTime; |
| TimeValue previewDuration; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetMoviePreviewTime(_self->ob_itself, |
| &previewTime, |
| &previewDuration); |
| _res = Py_BuildValue("ll", |
| previewTime, |
| previewDuration); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMoviePreviewTime(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue previewTime; |
| TimeValue previewDuration; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &previewTime, |
| &previewDuration)) |
| return NULL; |
| SetMoviePreviewTime(_self->ob_itself, |
| previewTime, |
| previewDuration); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMoviePosterTime(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMoviePosterTime(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMoviePosterTime(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue posterTime; |
| if (!PyArg_ParseTuple(_args, "l", |
| &posterTime)) |
| return NULL; |
| SetMoviePosterTime(_self->ob_itself, |
| posterTime); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieSelection(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue selectionTime; |
| TimeValue selectionDuration; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetMovieSelection(_self->ob_itself, |
| &selectionTime, |
| &selectionDuration); |
| _res = Py_BuildValue("ll", |
| selectionTime, |
| selectionDuration); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieSelection(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue selectionTime; |
| TimeValue selectionDuration; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &selectionTime, |
| &selectionDuration)) |
| return NULL; |
| SetMovieSelection(_self->ob_itself, |
| selectionTime, |
| selectionDuration); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieActiveSegment(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue startTime; |
| TimeValue duration; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| SetMovieActiveSegment(_self->ob_itself, |
| startTime, |
| duration); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieActiveSegment(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue startTime; |
| TimeValue duration; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetMovieActiveSegment(_self->ob_itself, |
| &startTime, |
| &duration); |
| _res = Py_BuildValue("ll", |
| startTime, |
| duration); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieTime(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| TimeRecord currentTime; |
| 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(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeRecord newtime; |
| 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(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue newtime; |
| if (!PyArg_ParseTuple(_args, "l", |
| &newtime)) |
| return NULL; |
| SetMovieTimeValue(_self->ob_itself, |
| newtime); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieUserData(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| UserData _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieUserData(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| UserDataObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieTrackCount(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieTrackCount(_self->ob_itself); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieTrack(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| long trackID; |
| if (!PyArg_ParseTuple(_args, "l", |
| &trackID)) |
| return NULL; |
| _rv = GetMovieTrack(_self->ob_itself, |
| trackID); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieIndTrack(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| long index; |
| if (!PyArg_ParseTuple(_args, "l", |
| &index)) |
| return NULL; |
| _rv = GetMovieIndTrack(_self->ob_itself, |
| index); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieIndTrackType(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| long index; |
| OSType trackType; |
| long flags; |
| if (!PyArg_ParseTuple(_args, "lO&l", |
| &index, |
| PyMac_GetOSType, &trackType, |
| &flags)) |
| return NULL; |
| _rv = GetMovieIndTrackType(_self->ob_itself, |
| index, |
| trackType, |
| flags); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_NewMovieTrack(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Track _rv; |
| Fixed width; |
| Fixed height; |
| short trackVolume; |
| if (!PyArg_ParseTuple(_args, "O&O&h", |
| PyMac_GetFixed, &width, |
| PyMac_GetFixed, &height, |
| &trackVolume)) |
| return NULL; |
| _rv = NewMovieTrack(_self->ob_itself, |
| width, |
| height, |
| trackVolume); |
| _res = Py_BuildValue("O&", |
| TrackObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetAutoTrackAlternatesEnabled(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Boolean enable; |
| if (!PyArg_ParseTuple(_args, "b", |
| &enable)) |
| return NULL; |
| SetAutoTrackAlternatesEnabled(_self->ob_itself, |
| enable); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SelectMovieAlternates(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| SelectMovieAlternates(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_InsertMovieSegment(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie dstMovie; |
| TimeValue srcIn; |
| TimeValue srcDuration; |
| TimeValue dstIn; |
| if (!PyArg_ParseTuple(_args, "O&lll", |
| MovieObj_Convert, &dstMovie, |
| &srcIn, |
| &srcDuration, |
| &dstIn)) |
| return NULL; |
| _err = InsertMovieSegment(_self->ob_itself, |
| dstMovie, |
| srcIn, |
| srcDuration, |
| dstIn); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_InsertEmptyMovieSegment(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue dstIn; |
| TimeValue dstDuration; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &dstIn, |
| &dstDuration)) |
| return NULL; |
| _err = InsertEmptyMovieSegment(_self->ob_itself, |
| dstIn, |
| dstDuration); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_DeleteMovieSegment(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue startTime; |
| TimeValue duration; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| _err = DeleteMovieSegment(_self->ob_itself, |
| startTime, |
| duration); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_ScaleMovieSegment(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue startTime; |
| TimeValue oldDuration; |
| TimeValue newDuration; |
| if (!PyArg_ParseTuple(_args, "lll", |
| &startTime, |
| &oldDuration, |
| &newDuration)) |
| return NULL; |
| _err = ScaleMovieSegment(_self->ob_itself, |
| startTime, |
| oldDuration, |
| newDuration); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_CutMovieSelection(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = CutMovieSelection(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_CopyMovieSelection(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = CopyMovieSelection(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PasteMovieSelection(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Movie src; |
| if (!PyArg_ParseTuple(_args, "O&", |
| MovieObj_Convert, &src)) |
| return NULL; |
| PasteMovieSelection(_self->ob_itself, |
| src); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_AddMovieSelection(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Movie src; |
| if (!PyArg_ParseTuple(_args, "O&", |
| MovieObj_Convert, &src)) |
| return NULL; |
| AddMovieSelection(_self->ob_itself, |
| src); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_ClearMovieSelection(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| ClearMovieSelection(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PutMovieIntoTypedHandle(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Track targetTrack; |
| OSType handleType; |
| Handle publicMovie; |
| TimeValue start; |
| TimeValue dur; |
| long flags; |
| ComponentInstance userComp; |
| if (!PyArg_ParseTuple(_args, "O&O&O&lllO&", |
| TrackObj_Convert, &targetTrack, |
| PyMac_GetOSType, &handleType, |
| ResObj_Convert, &publicMovie, |
| &start, |
| &dur, |
| &flags, |
| CmpInstObj_Convert, &userComp)) |
| return NULL; |
| _err = PutMovieIntoTypedHandle(_self->ob_itself, |
| targetTrack, |
| handleType, |
| publicMovie, |
| start, |
| dur, |
| flags, |
| userComp); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_CopyMovieSettings(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie dstMovie; |
| if (!PyArg_ParseTuple(_args, "O&", |
| MovieObj_Convert, &dstMovie)) |
| return NULL; |
| _err = CopyMovieSettings(_self->ob_itself, |
| dstMovie); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_ConvertMovieToFile(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Track onlyTrack; |
| FSSpec outputFile; |
| OSType fileType; |
| OSType creator; |
| ScriptCode scriptTag; |
| short resID; |
| long flags; |
| ComponentInstance userComp; |
| if (!PyArg_ParseTuple(_args, "O&O&O&O&hlO&", |
| TrackObj_Convert, &onlyTrack, |
| PyMac_GetFSSpec, &outputFile, |
| PyMac_GetOSType, &fileType, |
| PyMac_GetOSType, &creator, |
| &scriptTag, |
| &flags, |
| CmpInstObj_Convert, &userComp)) |
| return NULL; |
| _err = ConvertMovieToFile(_self->ob_itself, |
| onlyTrack, |
| &outputFile, |
| fileType, |
| creator, |
| scriptTag, |
| &resID, |
| flags, |
| userComp); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| resID); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieDataSize(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long _rv; |
| TimeValue startTime; |
| TimeValue duration; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &startTime, |
| &duration)) |
| return NULL; |
| _rv = GetMovieDataSize(_self->ob_itself, |
| startTime, |
| duration); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PtInMovie(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| Point pt; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetPoint, &pt)) |
| return NULL; |
| _rv = PtInMovie(_self->ob_itself, |
| pt); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieLanguage(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long language; |
| if (!PyArg_ParseTuple(_args, "l", |
| &language)) |
| return NULL; |
| SetMovieLanguage(_self->ob_itself, |
| language); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieNextInterestingTime(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| short interestingTimeFlags; |
| short numMediaTypes; |
| OSType whichMediaTypes; |
| TimeValue time; |
| Fixed rate; |
| TimeValue interestingTime; |
| TimeValue interestingDuration; |
| if (!PyArg_ParseTuple(_args, "hhO&lO&", |
| &interestingTimeFlags, |
| &numMediaTypes, |
| PyMac_GetOSType, &whichMediaTypes, |
| &time, |
| PyMac_GetFixed, &rate)) |
| return NULL; |
| GetMovieNextInterestingTime(_self->ob_itself, |
| interestingTimeFlags, |
| numMediaTypes, |
| &whichMediaTypes, |
| time, |
| rate, |
| &interestingTime, |
| &interestingDuration); |
| _res = Py_BuildValue("ll", |
| interestingTime, |
| interestingDuration); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_AddMovieResource(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short resRefNum; |
| short resId; |
| Str255 resName; |
| if (!PyArg_ParseTuple(_args, "hO&", |
| &resRefNum, |
| PyMac_GetStr255, resName)) |
| return NULL; |
| _err = AddMovieResource(_self->ob_itself, |
| resRefNum, |
| &resId, |
| resName); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| resId); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_UpdateMovieResource(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short resRefNum; |
| short resId; |
| Str255 resName; |
| if (!PyArg_ParseTuple(_args, "hhO&", |
| &resRefNum, |
| &resId, |
| PyMac_GetStr255, resName)) |
| return NULL; |
| _err = UpdateMovieResource(_self->ob_itself, |
| resRefNum, |
| resId, |
| resName); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_HasMovieChanged(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = HasMovieChanged(_self->ob_itself); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_ClearMovieChanged(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| ClearMovieChanged(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieDefaultDataRef(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle dataRef; |
| OSType dataRefType; |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| ResObj_Convert, &dataRef, |
| PyMac_GetOSType, &dataRefType)) |
| return NULL; |
| _err = SetMovieDefaultDataRef(_self->ob_itself, |
| dataRef, |
| dataRefType); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieDefaultDataRef(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle dataRef; |
| OSType dataRefType; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetMovieDefaultDataRef(_self->ob_itself, |
| &dataRef, |
| &dataRefType); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&O&", |
| ResObj_New, dataRef, |
| PyMac_BuildOSType, dataRefType); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMovieColorTable(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| CTabHandle ctab; |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &ctab)) |
| return NULL; |
| _err = SetMovieColorTable(_self->ob_itself, |
| ctab); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieColorTable(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| CTabHandle ctab; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetMovieColorTable(_self->ob_itself, |
| &ctab); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| ResObj_New, ctab); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_FlattenMovie(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long movieFlattenFlags; |
| FSSpec theFile; |
| OSType creator; |
| ScriptCode scriptTag; |
| long createMovieFileFlags; |
| short resId; |
| Str255 resName; |
| if (!PyArg_ParseTuple(_args, "lO&O&hlO&", |
| &movieFlattenFlags, |
| PyMac_GetFSSpec, &theFile, |
| PyMac_GetOSType, &creator, |
| &scriptTag, |
| &createMovieFileFlags, |
| PyMac_GetStr255, resName)) |
| return NULL; |
| FlattenMovie(_self->ob_itself, |
| movieFlattenFlags, |
| &theFile, |
| creator, |
| scriptTag, |
| createMovieFileFlags, |
| &resId, |
| resName); |
| _res = Py_BuildValue("h", |
| resId); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_FlattenMovieData(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| long movieFlattenFlags; |
| FSSpec theFile; |
| OSType creator; |
| ScriptCode scriptTag; |
| long createMovieFileFlags; |
| if (!PyArg_ParseTuple(_args, "lO&O&hl", |
| &movieFlattenFlags, |
| PyMac_GetFSSpec, &theFile, |
| PyMac_GetOSType, &creator, |
| &scriptTag, |
| &createMovieFileFlags)) |
| return NULL; |
| _rv = FlattenMovieData(_self->ob_itself, |
| movieFlattenFlags, |
| &theFile, |
| creator, |
| scriptTag, |
| createMovieFileFlags); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_MovieSearchText(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Ptr text; |
| long size; |
| long searchFlags; |
| Track searchTrack; |
| TimeValue searchTime; |
| long searchOffset; |
| if (!PyArg_ParseTuple(_args, "sll", |
| &text, |
| &size, |
| &searchFlags)) |
| return NULL; |
| _err = MovieSearchText(_self->ob_itself, |
| text, |
| size, |
| searchFlags, |
| &searchTrack, |
| &searchTime, |
| &searchOffset); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&ll", |
| TrackObj_New, searchTrack, |
| searchTime, |
| searchOffset); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetPosterBox(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Rect boxRect; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| GetPosterBox(_self->ob_itself, |
| &boxRect); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildRect, &boxRect); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetPosterBox(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Rect boxRect; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetRect, &boxRect)) |
| return NULL; |
| SetPosterBox(_self->ob_itself, |
| &boxRect); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieSegmentDisplayBoundsRgn(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| RgnHandle _rv; |
| TimeValue time; |
| TimeValue duration; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &time, |
| &duration)) |
| return NULL; |
| _rv = GetMovieSegmentDisplayBoundsRgn(_self->ob_itself, |
| time, |
| duration); |
| _res = Py_BuildValue("O&", |
| ResObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMovieStatus(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| Track firstProblemTrack; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetMovieStatus(_self->ob_itself, |
| &firstProblemTrack); |
| _res = Py_BuildValue("lO&", |
| _rv, |
| TrackObj_New, firstProblemTrack); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_NewMovieController(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| MovieController _rv; |
| Rect movieRect; |
| long someFlags; |
| if (!PyArg_ParseTuple(_args, "O&l", |
| PyMac_GetRect, &movieRect, |
| &someFlags)) |
| return NULL; |
| _rv = NewMovieController(_self->ob_itself, |
| &movieRect, |
| someFlags); |
| _res = Py_BuildValue("O&", |
| MovieCtlObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *MovieObj_PutMovieOnScrap(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| long movieScrapFlags; |
| if (!PyArg_ParseTuple(_args, "l", |
| &movieScrapFlags)) |
| return NULL; |
| _err = PutMovieOnScrap(_self->ob_itself, |
| movieScrapFlags); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_SetMoviePlayHints(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long flags; |
| long flagsMask; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &flags, |
| &flagsMask)) |
| return NULL; |
| SetMoviePlayHints(_self->ob_itself, |
| flags, |
| flagsMask); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *MovieObj_GetMaxLoadedTimeInMovie(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| TimeValue time; |
| 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(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Boolean needsTimeTable; |
| 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(_self, _args) |
| MovieObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| OSType dataRefType; |
| Handle dataRef; |
| long offset; |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| PyMac_GetOSType, &dataRefType, |
| ResObj_Convert, &dataRef)) |
| return NULL; |
| _err = QTGetDataRefMaxFileOffset(_self->ob_itself, |
| dataRefType, |
| dataRef, |
| &offset); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| offset); |
| return _res; |
| } |
| |
| static PyMethodDef MovieObj_methods[] = { |
| {"MoviesTask", (PyCFunction)MovieObj_MoviesTask, 1, |
| "(long maxMilliSecToUse) -> None"}, |
| {"PrerollMovie", (PyCFunction)MovieObj_PrerollMovie, 1, |
| "(TimeValue time, Fixed Rate) -> None"}, |
| {"LoadMovieIntoRam", (PyCFunction)MovieObj_LoadMovieIntoRam, 1, |
| "(TimeValue time, TimeValue duration, long flags) -> None"}, |
| {"SetMovieActive", (PyCFunction)MovieObj_SetMovieActive, 1, |
| "(Boolean active) -> None"}, |
| {"GetMovieActive", (PyCFunction)MovieObj_GetMovieActive, 1, |
| "() -> (Boolean _rv)"}, |
| {"StartMovie", (PyCFunction)MovieObj_StartMovie, 1, |
| "() -> None"}, |
| {"StopMovie", (PyCFunction)MovieObj_StopMovie, 1, |
| "() -> None"}, |
| {"GoToBeginningOfMovie", (PyCFunction)MovieObj_GoToBeginningOfMovie, 1, |
| "() -> None"}, |
| {"GoToEndOfMovie", (PyCFunction)MovieObj_GoToEndOfMovie, 1, |
| "() -> None"}, |
| {"IsMovieDone", (PyCFunction)MovieObj_IsMovieDone, 1, |
| "() -> (Boolean _rv)"}, |
| {"GetMoviePreviewMode", (PyCFunction)MovieObj_GetMoviePreviewMode, 1, |
| "() -> (Boolean _rv)"}, |
| {"SetMoviePreviewMode", (PyCFunction)MovieObj_SetMoviePreviewMode, 1, |
| "(Boolean usePreview) -> None"}, |
| {"ShowMoviePoster", (PyCFunction)MovieObj_ShowMoviePoster, 1, |
| "() -> None"}, |
| {"GetMovieTimeBase", (PyCFunction)MovieObj_GetMovieTimeBase, 1, |
| "() -> (TimeBase _rv)"}, |
| {"SetMovieMasterTimeBase", (PyCFunction)MovieObj_SetMovieMasterTimeBase, 1, |
| "(TimeBase tb, TimeRecord slaveZero) -> None"}, |
| {"SetMovieMasterClock", (PyCFunction)MovieObj_SetMovieMasterClock, 1, |
| "(Component clockMeister, TimeRecord slaveZero) -> None"}, |
| {"GetMovieGWorld", (PyCFunction)MovieObj_GetMovieGWorld, 1, |
| "() -> (CGrafPtr port, GDHandle gdh)"}, |
| {"SetMovieGWorld", (PyCFunction)MovieObj_SetMovieGWorld, 1, |
| "(CGrafPtr port, GDHandle gdh) -> None"}, |
| {"GetMovieNaturalBoundsRect", (PyCFunction)MovieObj_GetMovieNaturalBoundsRect, 1, |
| "() -> (Rect naturalBounds)"}, |
| {"GetNextTrackForCompositing", (PyCFunction)MovieObj_GetNextTrackForCompositing, 1, |
| "(Track theTrack) -> (Track _rv)"}, |
| {"GetPrevTrackForCompositing", (PyCFunction)MovieObj_GetPrevTrackForCompositing, 1, |
| "(Track theTrack) -> (Track _rv)"}, |
| {"GetMoviePict", (PyCFunction)MovieObj_GetMoviePict, 1, |
| "(TimeValue time) -> (PicHandle _rv)"}, |
| {"GetMoviePosterPict", (PyCFunction)MovieObj_GetMoviePosterPict, 1, |
| "() -> (PicHandle _rv)"}, |
| {"UpdateMovie", (PyCFunction)MovieObj_UpdateMovie, 1, |
| "() -> None"}, |
| {"InvalidateMovieRegion", (PyCFunction)MovieObj_InvalidateMovieRegion, 1, |
| "(RgnHandle invalidRgn) -> None"}, |
| {"GetMovieBox", (PyCFunction)MovieObj_GetMovieBox, 1, |
| "() -> (Rect boxRect)"}, |
| {"SetMovieBox", (PyCFunction)MovieObj_SetMovieBox, 1, |
| "(Rect boxRect) -> None"}, |
| {"GetMovieDisplayClipRgn", (PyCFunction)MovieObj_GetMovieDisplayClipRgn, 1, |
| "() -> (RgnHandle _rv)"}, |
| {"SetMovieDisplayClipRgn", (PyCFunction)MovieObj_SetMovieDisplayClipRgn, 1, |
| "(RgnHandle theClip) -> None"}, |
| {"GetMovieClipRgn", (PyCFunction)MovieObj_GetMovieClipRgn, 1, |
| "() -> (RgnHandle _rv)"}, |
| {"SetMovieClipRgn", (PyCFunction)MovieObj_SetMovieClipRgn, 1, |
| "(RgnHandle theClip) -> None"}, |
| {"GetMovieDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieDisplayBoundsRgn, 1, |
| "() -> (RgnHandle _rv)"}, |
| {"GetMovieBoundsRgn", (PyCFunction)MovieObj_GetMovieBoundsRgn, 1, |
| "() -> (RgnHandle _rv)"}, |
| {"PutMovieIntoHandle", (PyCFunction)MovieObj_PutMovieIntoHandle, 1, |
| "(Handle publicMovie) -> None"}, |
| {"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1, |
| "(short fRefNum, long offset, long maxSize) -> None"}, |
| {"GetMovieCreationTime", (PyCFunction)MovieObj_GetMovieCreationTime, 1, |
| "() -> (unsigned long _rv)"}, |
| {"GetMovieModificationTime", (PyCFunction)MovieObj_GetMovieModificationTime, 1, |
| "() -> (unsigned long _rv)"}, |
| {"GetMovieTimeScale", (PyCFunction)MovieObj_GetMovieTimeScale, 1, |
| "() -> (TimeScale _rv)"}, |
| {"SetMovieTimeScale", (PyCFunction)MovieObj_SetMovieTimeScale, 1, |
| "(TimeScale timeScale) -> None"}, |
| {"GetMovieDuration", (PyCFunction)MovieObj_GetMovieDuration, 1, |
| "() -> (TimeValue _rv)"}, |
| {"GetMovieRate", (PyCFunction)MovieObj_GetMovieRate, 1, |
| "() -> (Fixed _rv)"}, |
| {"SetMovieRate", (PyCFunction)MovieObj_SetMovieRate, 1, |
| "(Fixed rate) -> None"}, |
| {"GetMoviePreferredRate", (PyCFunction)MovieObj_GetMoviePreferredRate, 1, |
| "() -> (Fixed _rv)"}, |
| {"SetMoviePreferredRate", (PyCFunction)MovieObj_SetMoviePreferredRate, 1, |
| "(Fixed rate) -> None"}, |
| {"GetMoviePreferredVolume", (PyCFunction)MovieObj_GetMoviePreferredVolume, 1, |
| "() -> (short _rv)"}, |
| {"SetMoviePreferredVolume", (PyCFunction)MovieObj_SetMoviePreferredVolume, 1, |
| "(short volume) -> None"}, |
| {"GetMovieVolume", (PyCFunction)MovieObj_GetMovieVolume, 1, |
| "() -> (short _rv)"}, |
| {"SetMovieVolume", (PyCFunction)MovieObj_SetMovieVolume, 1, |
| "(short volume) -> None"}, |
| {"GetMoviePreviewTime", (PyCFunction)MovieObj_GetMoviePreviewTime, 1, |
| "() -> (TimeValue previewTime, TimeValue previewDuration)"}, |
| {"SetMoviePreviewTime", (PyCFunction)MovieObj_SetMoviePreviewTime, 1, |
| "(TimeValue previewTime, TimeValue previewDuration) -> None"}, |
| {"GetMoviePosterTime", (PyCFunction)MovieObj_GetMoviePosterTime, 1, |
| "() -> (TimeValue _rv)"}, |
| {"SetMoviePosterTime", (PyCFunction)MovieObj_SetMoviePosterTime, 1, |
| "(TimeValue posterTime) -> None"}, |
| {"GetMovieSelection", (PyCFunction)MovieObj_GetMovieSelection, 1, |
| "() -> (TimeValue selectionTime, TimeValue selectionDuration)"}, |
| {"SetMovieSelection", (PyCFunction)MovieObj_SetMovieSelection, 1, |
| "(TimeValue selectionTime, TimeValue selectionDuration) -> None"}, |
| {"SetMovieActiveSegment", (PyCFunction)MovieObj_SetMovieActiveSegment, 1, |
| "(TimeValue startTime, TimeValue duration) -> None"}, |
| {"GetMovieActiveSegment", (PyCFunction)MovieObj_GetMovieActiveSegment, 1, |
| "() -> (TimeValue startTime, TimeValue duration)"}, |
| {"GetMovieTime", (PyCFunction)MovieObj_GetMovieTime, 1, |
| "() -> (TimeValue _rv, TimeRecord currentTime)"}, |
| {"SetMovieTime", (PyCFunction)MovieObj_SetMovieTime, 1, |
| "(TimeRecord newtime) -> None"}, |
| {"SetMovieTimeValue", (PyCFunction)MovieObj_SetMovieTimeValue, 1, |
| "(TimeValue newtime) -> None"}, |
| {"GetMovieUserData", (PyCFunction)MovieObj_GetMovieUserData, 1, |
| "() -> (UserData _rv)"}, |
| {"GetMovieTrackCount", (PyCFunction)MovieObj_GetMovieTrackCount, 1, |
| "() -> (long _rv)"}, |
| {"GetMovieTrack", (PyCFunction)MovieObj_GetMovieTrack, 1, |
| "(long trackID) -> (Track _rv)"}, |
| {"GetMovieIndTrack", (PyCFunction)MovieObj_GetMovieIndTrack, 1, |
| "(long index) -> (Track _rv)"}, |
| {"GetMovieIndTrackType", (PyCFunction)MovieObj_GetMovieIndTrackType, 1, |
| "(long index, OSType trackType, long flags) -> (Track _rv)"}, |
| {"NewMovieTrack", (PyCFunction)MovieObj_NewMovieTrack, 1, |
| "(Fixed width, Fixed height, short trackVolume) -> (Track _rv)"}, |
| {"SetAutoTrackAlternatesEnabled", (PyCFunction)MovieObj_SetAutoTrackAlternatesEnabled, 1, |
| "(Boolean enable) -> None"}, |
| {"SelectMovieAlternates", (PyCFunction)MovieObj_SelectMovieAlternates, 1, |
| "() -> None"}, |
| {"InsertMovieSegment", (PyCFunction)MovieObj_InsertMovieSegment, 1, |
| "(Movie dstMovie, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None"}, |
| {"InsertEmptyMovieSegment", (PyCFunction)MovieObj_InsertEmptyMovieSegment, 1, |
| "(TimeValue dstIn, TimeValue dstDuration) -> None"}, |
| {"DeleteMovieSegment", (PyCFunction)MovieObj_DeleteMovieSegment, 1, |
| "(TimeValue startTime, TimeValue duration) -> None"}, |
| {"ScaleMovieSegment", (PyCFunction)MovieObj_ScaleMovieSegment, 1, |
| "(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None"}, |
| {"CutMovieSelection", (PyCFunction)MovieObj_CutMovieSelection, 1, |
| "() -> (Movie _rv)"}, |
| {"CopyMovieSelection", (PyCFunction)MovieObj_CopyMovieSelection, 1, |
| "() -> (Movie _rv)"}, |
| {"PasteMovieSelection", (PyCFunction)MovieObj_PasteMovieSelection, 1, |
| "(Movie src) -> None"}, |
| {"AddMovieSelection", (PyCFunction)MovieObj_AddMovieSelection, 1, |
| "(Movie src) -> None"}, |
| {"ClearMovieSelection", (PyCFunction)MovieObj_ClearMovieSelection, 1, |
| "() -> None"}, |
| {"PutMovieIntoTypedHandle", (PyCFunction)MovieObj_PutMovieIntoTypedHandle, 1, |
| "(Track targetTrack, OSType handleType, Handle publicMovie, TimeValue start, TimeValue dur, long flags, ComponentInstance userComp) -> None"}, |
| {"CopyMovieSettings", (PyCFunction)MovieObj_CopyMovieSettings, 1, |
| "(Movie dstMovie) -> None"}, |
| {"ConvertMovieToFile", (PyCFunction)MovieObj_ConvertMovieToFile, 1, |
| "(Track onlyTrack, FSSpec outputFile, OSType fileType, OSType creator, ScriptCode scriptTag, long flags, ComponentInstance userComp) -> (short resID)"}, |
| {"GetMovieDataSize", (PyCFunction)MovieObj_GetMovieDataSize, 1, |
| "(TimeValue startTime, TimeValue duration) -> (long _rv)"}, |
| {"PtInMovie", (PyCFunction)MovieObj_PtInMovie, 1, |
| "(Point pt) -> (Boolean _rv)"}, |
| {"SetMovieLanguage", (PyCFunction)MovieObj_SetMovieLanguage, 1, |
| "(long language) -> None"}, |
| {"GetMovieNextInterestingTime", (PyCFunction)MovieObj_GetMovieNextInterestingTime, 1, |
| "(short interestingTimeFlags, short numMediaTypes, OSType whichMediaTypes, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"}, |
| {"AddMovieResource", (PyCFunction)MovieObj_AddMovieResource, 1, |
| "(short resRefNum, Str255 resName) -> (short resId)"}, |
| {"UpdateMovieResource", (PyCFunction)MovieObj_UpdateMovieResource, 1, |
| "(short resRefNum, short resId, Str255 resName) -> None"}, |
| {"HasMovieChanged", (PyCFunction)MovieObj_HasMovieChanged, 1, |
| "() -> (Boolean _rv)"}, |
| {"ClearMovieChanged", (PyCFunction)MovieObj_ClearMovieChanged, 1, |
| "() -> None"}, |
| {"SetMovieDefaultDataRef", (PyCFunction)MovieObj_SetMovieDefaultDataRef, 1, |
| "(Handle dataRef, OSType dataRefType) -> None"}, |
| {"GetMovieDefaultDataRef", (PyCFunction)MovieObj_GetMovieDefaultDataRef, 1, |
| "() -> (Handle dataRef, OSType dataRefType)"}, |
| {"SetMovieColorTable", (PyCFunction)MovieObj_SetMovieColorTable, 1, |
| "(CTabHandle ctab) -> None"}, |
| {"GetMovieColorTable", (PyCFunction)MovieObj_GetMovieColorTable, 1, |
| "() -> (CTabHandle ctab)"}, |
| {"FlattenMovie", (PyCFunction)MovieObj_FlattenMovie, 1, |
| "(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Str255 resName) -> (short resId)"}, |
| {"FlattenMovieData", (PyCFunction)MovieObj_FlattenMovieData, 1, |
| "(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)"}, |
| {"MovieSearchText", (PyCFunction)MovieObj_MovieSearchText, 1, |
| "(Ptr text, long size, long searchFlags) -> (Track searchTrack, TimeValue searchTime, long searchOffset)"}, |
| {"GetPosterBox", (PyCFunction)MovieObj_GetPosterBox, 1, |
| "() -> (Rect boxRect)"}, |
| {"SetPosterBox", (PyCFunction)MovieObj_SetPosterBox, 1, |
| "(Rect boxRect) -> None"}, |
| {"GetMovieSegmentDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieSegmentDisplayBoundsRgn, 1, |
| "(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"}, |
| {"GetMovieStatus", (PyCFunction)MovieObj_GetMovieStatus, 1, |
| "() -> (ComponentResult _rv, Track firstProblemTrack)"}, |
| {"NewMovieController", (PyCFunction)MovieObj_NewMovieController, 1, |
| "(Rect movieRect, long someFlags) -> (MovieController _rv)"}, |
| {"PutMovieOnScrap", (PyCFunction)MovieObj_PutMovieOnScrap, 1, |
| "(long movieScrapFlags) -> None"}, |
| {"SetMoviePlayHints", (PyCFunction)MovieObj_SetMoviePlayHints, 1, |
| "(long flags, long flagsMask) -> None"}, |
| {"GetMaxLoadedTimeInMovie", (PyCFunction)MovieObj_GetMaxLoadedTimeInMovie, 1, |
| "() -> (TimeValue time)"}, |
| {"QTMovieNeedsTimeTable", (PyCFunction)MovieObj_QTMovieNeedsTimeTable, 1, |
| "() -> (Boolean needsTimeTable)"}, |
| {"QTGetDataRefMaxFileOffset", (PyCFunction)MovieObj_QTGetDataRefMaxFileOffset, 1, |
| "(OSType dataRefType, Handle dataRef) -> (long offset)"}, |
| {NULL, NULL, 0} |
| }; |
| |
| PyMethodChain MovieObj_chain = { MovieObj_methods, NULL }; |
| |
| static PyObject *MovieObj_getattr(self, name) |
| MovieObject *self; |
| char *name; |
| { |
| return Py_FindMethodInChain(&MovieObj_chain, (PyObject *)self, name); |
| } |
| |
| #define MovieObj_setattr NULL |
| |
| #define MovieObj_compare NULL |
| |
| #define MovieObj_repr NULL |
| |
| #define MovieObj_hash NULL |
| |
| PyTypeObject Movie_Type = { |
| PyObject_HEAD_INIT(&PyType_Type) |
| 0, /*ob_size*/ |
| "Movie", /*tp_name*/ |
| sizeof(MovieObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) MovieObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc) MovieObj_getattr, /*tp_getattr*/ |
| (setattrfunc) MovieObj_setattr, /*tp_setattr*/ |
| (cmpfunc) MovieObj_compare, /*tp_compare*/ |
| (reprfunc) MovieObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) MovieObj_hash, /*tp_hash*/ |
| }; |
| |
| /* --------------------- End object type Movie ---------------------- */ |
| |
| |
| static PyObject *Qt_CheckQuickTimeRegistration(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| void * registrationKey; |
| long flags; |
| if (!PyArg_ParseTuple(_args, "sl", |
| ®istrationKey, |
| &flags)) |
| return NULL; |
| CheckQuickTimeRegistration(registrationKey, |
| flags); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_EnterMovies(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = EnterMovies(); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_ExitMovies(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| ExitMovies(); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_GetMoviesError(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetMoviesError(); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_ClearMoviesStickyError(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| ClearMoviesStickyError(); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_GetMoviesStickyError(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = GetMoviesStickyError(); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_DisposeMatte(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| PixMapHandle theMatte; |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &theMatte)) |
| return NULL; |
| DisposeMatte(theMatte); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_NewMovie(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| long flags; |
| if (!PyArg_ParseTuple(_args, "l", |
| &flags)) |
| return NULL; |
| _rv = NewMovie(flags); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_GetDataHandler(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Component _rv; |
| Handle dataRef; |
| OSType dataHandlerSubType; |
| long flags; |
| if (!PyArg_ParseTuple(_args, "O&O&l", |
| ResObj_Convert, &dataRef, |
| PyMac_GetOSType, &dataHandlerSubType, |
| &flags)) |
| return NULL; |
| _rv = GetDataHandler(dataRef, |
| dataHandlerSubType, |
| flags); |
| _res = Py_BuildValue("O&", |
| CmpObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_PasteHandleIntoMovie(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle h; |
| OSType handleType; |
| Movie theMovie; |
| long flags; |
| ComponentInstance userComp; |
| if (!PyArg_ParseTuple(_args, "O&O&O&lO&", |
| ResObj_Convert, &h, |
| PyMac_GetOSType, &handleType, |
| MovieObj_Convert, &theMovie, |
| &flags, |
| CmpInstObj_Convert, &userComp)) |
| return NULL; |
| _err = PasteHandleIntoMovie(h, |
| handleType, |
| theMovie, |
| flags, |
| userComp); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_GetMovieImporterForDataRef(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| OSType dataRefType; |
| Handle dataRef; |
| long flags; |
| Component importer; |
| 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_TrackTimeToMediaTime(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeValue _rv; |
| TimeValue value; |
| Track theTrack; |
| if (!PyArg_ParseTuple(_args, "lO&", |
| &value, |
| TrackObj_Convert, &theTrack)) |
| return NULL; |
| _rv = TrackTimeToMediaTime(value, |
| theTrack); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_NewUserData(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| UserData theUserData; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = NewUserData(&theUserData); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| UserDataObj_New, theUserData); |
| return _res; |
| } |
| |
| static PyObject *Qt_NewUserDataFromHandle(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle h; |
| UserData theUserData; |
| if (!PyArg_ParseTuple(_args, "O&", |
| ResObj_Convert, &h)) |
| return NULL; |
| _err = NewUserDataFromHandle(h, |
| &theUserData); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| UserDataObj_New, theUserData); |
| return _res; |
| } |
| |
| static PyObject *Qt_CreateMovieFile(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| FSSpec fileSpec; |
| OSType creator; |
| ScriptCode scriptTag; |
| long createMovieFileFlags; |
| short resRefNum; |
| Movie newmovie; |
| if (!PyArg_ParseTuple(_args, "O&O&hl", |
| PyMac_GetFSSpec, &fileSpec, |
| PyMac_GetOSType, &creator, |
| &scriptTag, |
| &createMovieFileFlags)) |
| return NULL; |
| _err = CreateMovieFile(&fileSpec, |
| creator, |
| scriptTag, |
| createMovieFileFlags, |
| &resRefNum, |
| &newmovie); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("hO&", |
| resRefNum, |
| MovieObj_New, newmovie); |
| return _res; |
| } |
| |
| static PyObject *Qt_OpenMovieFile(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| FSSpec fileSpec; |
| short resRefNum; |
| SInt8 permission; |
| if (!PyArg_ParseTuple(_args, "O&b", |
| PyMac_GetFSSpec, &fileSpec, |
| &permission)) |
| return NULL; |
| _err = OpenMovieFile(&fileSpec, |
| &resRefNum, |
| permission); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| resRefNum); |
| return _res; |
| } |
| |
| static PyObject *Qt_CloseMovieFile(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short resRefNum; |
| if (!PyArg_ParseTuple(_args, "h", |
| &resRefNum)) |
| return NULL; |
| _err = CloseMovieFile(resRefNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_DeleteMovieFile(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| FSSpec fileSpec; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetFSSpec, &fileSpec)) |
| return NULL; |
| _err = DeleteMovieFile(&fileSpec); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_NewMovieFromFile(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie theMovie; |
| short resRefNum; |
| short resId; |
| short newMovieFlags; |
| Boolean dataRefWasChanged; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie theMovie; |
| Handle h; |
| short newMovieFlags; |
| Boolean dataRefWasChanged; |
| if (!PyArg_ParseTuple(_args, "O&h", |
| ResObj_Convert, &h, |
| &newMovieFlags)) |
| return NULL; |
| _err = NewMovieFromHandle(&theMovie, |
| h, |
| newMovieFlags, |
| &dataRefWasChanged); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&b", |
| MovieObj_New, theMovie, |
| dataRefWasChanged); |
| return _res; |
| } |
| |
| static PyObject *Qt_NewMovieFromDataFork(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie theMovie; |
| short fRefNum; |
| long fileOffset; |
| short newMovieFlags; |
| Boolean dataRefWasChanged; |
| if (!PyArg_ParseTuple(_args, "hlh", |
| &fRefNum, |
| &fileOffset, |
| &newMovieFlags)) |
| return NULL; |
| _err = NewMovieFromDataFork(&theMovie, |
| fRefNum, |
| fileOffset, |
| newMovieFlags, |
| &dataRefWasChanged); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&b", |
| MovieObj_New, theMovie, |
| dataRefWasChanged); |
| return _res; |
| } |
| |
| static PyObject *Qt_NewMovieFromDataRef(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Movie m; |
| short flags; |
| short id; |
| Handle dataRef; |
| OSType dataRefType; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short resRefNum; |
| short resId; |
| if (!PyArg_ParseTuple(_args, "hh", |
| &resRefNum, |
| &resId)) |
| return NULL; |
| _err = RemoveMovieResource(resRefNum, |
| resId); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_NewMovieFromScrap(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| Movie _rv; |
| long newMovieFlags; |
| if (!PyArg_ParseTuple(_args, "l", |
| &newMovieFlags)) |
| return NULL; |
| _rv = NewMovieFromScrap(newMovieFlags); |
| _res = Py_BuildValue("O&", |
| MovieObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_QTNewAlias(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| FSSpec fss; |
| AliasHandle alias; |
| Boolean minimal; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Ptr fullState; |
| long flags; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SoundDescriptionHandle desc; |
| Handle extension; |
| OSType idType; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SoundDescriptionHandle desc; |
| Handle extension; |
| OSType idType; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SoundDescriptionHandle desc; |
| OSType idType; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| EventRecord pEvent; |
| QTParameterDialog createdDialog; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| QTParameterDialog createdDialog; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| QTParameterDialog createdDialog; |
| long action; |
| void * params; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Str255 accessKeyType; |
| long flags; |
| Handle accessKey; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Str255 accessKeyType; |
| long flags; |
| Handle accessKey; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Handle theText; |
| long encoding; |
| long flags; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpInstObj_Convert, &mh)) |
| return NULL; |
| _rv = VideoMediaResetStatistics(mh); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_VideoMediaGetStatistics(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| if (!PyArg_ParseTuple(_args, "O&", |
| CmpInstObj_Convert, &mh)) |
| return NULL; |
| _rv = VideoMediaGetStatistics(mh); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_VideoMediaGetStallCount(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| unsigned long stalls; |
| 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_TextMediaAddTextSample(_self, _args) |
| 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; |
| 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(_self, _args) |
| 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; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short hiliteStart; |
| short hiliteEnd; |
| RGBColor rgbHiliteColor; |
| TimeValue duration; |
| TimeValue sampleTime; |
| 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_TextMediaFindNextText(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| Ptr text; |
| long size; |
| short findFlags; |
| TimeValue startTime; |
| TimeValue foundTime; |
| TimeValue foundDuration; |
| long offset; |
| if (!PyArg_ParseTuple(_args, "O&slhl", |
| CmpInstObj_Convert, &mh, |
| &text, |
| &size, |
| &findFlags, |
| &startTime)) |
| return NULL; |
| _rv = TextMediaFindNextText(mh, |
| text, |
| size, |
| findFlags, |
| startTime, |
| &foundTime, |
| &foundDuration, |
| &offset); |
| _res = Py_BuildValue("llll", |
| _rv, |
| foundTime, |
| foundDuration, |
| offset); |
| return _res; |
| } |
| |
| static PyObject *Qt_TextMediaHiliteTextSample(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| TimeValue sampleTime; |
| short hiliteStart; |
| short hiliteEnd; |
| RGBColor rgbHiliteColor; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| void * data; |
| OSType dataType; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short spriteIndex; |
| long propertyType; |
| void * propertyValue; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short spriteIndex; |
| long propertyType; |
| void * propertyValue; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| long flags; |
| Point loc; |
| short spriteHitIndex; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short numSprites; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short numImages; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short imageIndex; |
| ImageDescriptionHandle imageDescription; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| long sampleNum; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID spriteID; |
| Str255 spriteName; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short imageIndex; |
| Str255 imageName; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID spriteID; |
| long propertyType; |
| void * propertyValue; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID spriteID; |
| long propertyType; |
| void * propertyValue; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| long flags; |
| Point loc; |
| QTAtomID spriteHitID; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID spriteID; |
| long flags; |
| Point loc; |
| Boolean wasHit; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short spriteIndex; |
| QTAtomID spriteID; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID spriteID; |
| short spriteIndex; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID variableID; |
| float value; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| QTAtomID variableID; |
| float value; |
| 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_SpriteMediaGetIndImageProperty(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| MediaHandler mh; |
| short imageIndex; |
| long imagePropertyType; |
| void * imagePropertyValue; |
| if (!PyArg_ParseTuple(_args, "O&hls", |
| CmpInstObj_Convert, &mh, |
| &imageIndex, |
| &imagePropertyType, |
| &imagePropertyValue)) |
| return NULL; |
| _rv = SpriteMediaGetIndImageProperty(mh, |
| imageIndex, |
| imagePropertyType, |
| imagePropertyValue); |
| _res = Py_BuildValue("l", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_NewTimeBase(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeBase _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = NewTimeBase(); |
| _res = Py_BuildValue("O&", |
| TimeBaseObj_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *Qt_ConvertTime(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeRecord inout; |
| TimeBase newBase; |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| QtTimeRecord_Convert, &inout, |
| TimeBaseObj_Convert, &newBase)) |
| return NULL; |
| ConvertTime(&inout, |
| newBase); |
| _res = Py_BuildValue("O&", |
| QtTimeRecord_New, &inout); |
| return _res; |
| } |
| |
| static PyObject *Qt_ConvertTimeScale(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeRecord inout; |
| TimeScale newScale; |
| if (!PyArg_ParseTuple(_args, "O&l", |
| QtTimeRecord_Convert, &inout, |
| &newScale)) |
| return NULL; |
| ConvertTimeScale(&inout, |
| newScale); |
| _res = Py_BuildValue("O&", |
| QtTimeRecord_New, &inout); |
| return _res; |
| } |
| |
| static PyObject *Qt_AddTime(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeRecord dst; |
| TimeRecord src; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| TimeRecord dst; |
| TimeRecord src; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| ComponentResult _rv; |
| ComponentInstance ti; |
| long sampleDescIndex; |
| ComponentInstance tp; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| WindowPtr wp; |
| Boolean front; |
| 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(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| WindowPtr wp; |
| Point startPt; |
| Rect boundsRect; |
| if (!PyArg_ParseTuple(_args, "O&O&O&", |
| WinObj_Convert, &wp, |
| PyMac_GetPoint, &startPt, |
| PyMac_GetRect, &boundsRect)) |
| return NULL; |
| DragAlignedWindow(wp, |
| startPt, |
| &boundsRect, |
| (Rect *)0, |
| (ICMAlignmentProcRecordPtr)0); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *Qt_MoviesTask(_self, _args) |
| PyObject *_self; |
| PyObject *_args; |
| { |
| PyObject *_res = NULL; |
| long maxMilliSecToUse; |
| 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[] = { |
| {"CheckQuickTimeRegistration", (PyCFunction)Qt_CheckQuickTimeRegistration, 1, |
| "(void * registrationKey, long flags) -> None"}, |
| {"EnterMovies", (PyCFunction)Qt_EnterMovies, 1, |
| "() -> None"}, |
| {"ExitMovies", (PyCFunction)Qt_ExitMovies, 1, |
| "() -> None"}, |
| {"GetMoviesError", (PyCFunction)Qt_GetMoviesError, 1, |
| "() -> None"}, |
| {"ClearMoviesStickyError", (PyCFunction)Qt_ClearMoviesStickyError, 1, |
| "() -> None"}, |
| {"GetMoviesStickyError", (PyCFunction)Qt_GetMoviesStickyError, 1, |
| "() -> None"}, |
| {"DisposeMatte", (PyCFunction)Qt_DisposeMatte, 1, |
| "(PixMapHandle theMatte) -> None"}, |
| {"NewMovie", (PyCFunction)Qt_NewMovie, 1, |
| "(long flags) -> (Movie _rv)"}, |
| {"GetDataHandler", (PyCFunction)Qt_GetDataHandler, 1, |
| "(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)"}, |
| {"PasteHandleIntoMovie", (PyCFunction)Qt_PasteHandleIntoMovie, 1, |
| "(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None"}, |
| {"GetMovieImporterForDataRef", (PyCFunction)Qt_GetMovieImporterForDataRef, 1, |
| "(OSType dataRefType, Handle dataRef, long flags) -> (Component importer)"}, |
| {"TrackTimeToMediaTime", (PyCFunction)Qt_TrackTimeToMediaTime, 1, |
| "(TimeValue value, Track theTrack) -> (TimeValue _rv)"}, |
| {"NewUserData", (PyCFunction)Qt_NewUserData, 1, |
| "() -> (UserData theUserData)"}, |
| {"NewUserDataFromHandle", (PyCFunction)Qt_NewUserDataFromHandle, 1, |
| "(Handle h) -> (UserData theUserData)"}, |
| {"CreateMovieFile", (PyCFunction)Qt_CreateMovieFile, 1, |
| "(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (short resRefNum, Movie newmovie)"}, |
| {"OpenMovieFile", (PyCFunction)Qt_OpenMovieFile, 1, |
| "(FSSpec fileSpec, SInt8 permission) -> (short resRefNum)"}, |
| {"CloseMovieFile", (PyCFunction)Qt_CloseMovieFile, 1, |
| "(short resRefNum) -> None"}, |
| {"DeleteMovieFile", (PyCFunction)Qt_DeleteMovieFile, 1, |
| "(FSSpec fileSpec) -> None"}, |
| {"NewMovieFromFile", (PyCFunction)Qt_NewMovieFromFile, 1, |
| "(short resRefNum, short resId, short newMovieFlags) -> (Movie theMovie, short resId, Boolean dataRefWasChanged)"}, |
| {"NewMovieFromHandle", (PyCFunction)Qt_NewMovieFromHandle, 1, |
| "(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"}, |
| {"NewMovieFromDataFork", (PyCFunction)Qt_NewMovieFromDataFork, 1, |
| "(short fRefNum, long fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"}, |
| {"NewMovieFromDataRef", (PyCFunction)Qt_NewMovieFromDataRef, 1, |
| "(short flags, Handle dataRef, OSType dataRefType) -> (Movie m, short id)"}, |
| {"RemoveMovieResource", (PyCFunction)Qt_RemoveMovieResource, 1, |
| "(short resRefNum, short resId) -> None"}, |
| {"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1, |
| "(long newMovieFlags) -> (Movie _rv)"}, |
| {"QTNewAlias", (PyCFunction)Qt_QTNewAlias, 1, |
| "(FSSpec fss, Boolean minimal) -> (AliasHandle alias)"}, |
| {"EndFullScreen", (PyCFunction)Qt_EndFullScreen, 1, |
| "(Ptr fullState, long flags) -> None"}, |
| {"AddSoundDescriptionExtension", (PyCFunction)Qt_AddSoundDescriptionExtension, 1, |
| "(SoundDescriptionHandle desc, Handle extension, OSType idType) -> None"}, |
| {"GetSoundDescriptionExtension", (PyCFunction)Qt_GetSoundDescriptionExtension, 1, |
| "(SoundDescriptionHandle desc, OSType idType) -> (Handle extension)"}, |
| {"RemoveSoundDescriptionExtension", (PyCFunction)Qt_RemoveSoundDescriptionExtension, 1, |
| "(SoundDescriptionHandle desc, OSType idType) -> None"}, |
| {"QTIsStandardParameterDialogEvent", (PyCFunction)Qt_QTIsStandardParameterDialogEvent, 1, |
| "(QTParameterDialog createdDialog) -> (EventRecord pEvent)"}, |
| {"QTDismissStandardParameterDialog", (PyCFunction)Qt_QTDismissStandardParameterDialog, 1, |
| "(QTParameterDialog createdDialog) -> None"}, |
| {"QTStandardParameterDialogDoAction", (PyCFunction)Qt_QTStandardParameterDialogDoAction, 1, |
| "(QTParameterDialog createdDialog, long action, void * params) -> None"}, |
| {"QTRegisterAccessKey", (PyCFunction)Qt_QTRegisterAccessKey, 1, |
| "(Str255 accessKeyType, long flags, Handle accessKey) -> None"}, |
| {"QTUnregisterAccessKey", (PyCFunction)Qt_QTUnregisterAccessKey, 1, |
| "(Str255 accessKeyType, long flags, Handle accessKey) -> None"}, |
| {"QTTextToNativeText", (PyCFunction)Qt_QTTextToNativeText, 1, |
| "(Handle theText, long encoding, long flags) -> None"}, |
| {"VideoMediaResetStatistics", (PyCFunction)Qt_VideoMediaResetStatistics, 1, |
| "(MediaHandler mh) -> (ComponentResult _rv)"}, |
| {"VideoMediaGetStatistics", (PyCFunction)Qt_VideoMediaGetStatistics, 1, |
| "(MediaHandler mh) -> (ComponentResult _rv)"}, |
| {"VideoMediaGetStallCount", (PyCFunction)Qt_VideoMediaGetStallCount, 1, |
| "(MediaHandler mh) -> (ComponentResult _rv, unsigned long stalls)"}, |
| {"TextMediaAddTextSample", (PyCFunction)Qt_TextMediaAddTextSample, 1, |
| "(MediaHandler mh, Ptr text, unsigned long size, short fontNumber, short fontSize, Style textFace, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor textColor, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)"}, |
| {"TextMediaAddTESample", (PyCFunction)Qt_TextMediaAddTESample, 1, |
| "(MediaHandler mh, TEHandle hTE, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)"}, |
| {"TextMediaAddHiliteSample", (PyCFunction)Qt_TextMediaAddHiliteSample, 1, |
| "(MediaHandler mh, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor rgbHiliteColor, TimeValue sampleTime)"}, |
| {"TextMediaFindNextText", (PyCFunction)Qt_TextMediaFindNextText, 1, |
| "(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)"}, |
| {"TextMediaHiliteTextSample", (PyCFunction)Qt_TextMediaHiliteTextSample, 1, |
| "(MediaHandler mh, TimeValue sampleTime, short hiliteStart, short hiliteEnd) -> (ComponentResult _rv, RGBColor rgbHiliteColor)"}, |
| {"TextMediaSetTextSampleData", (PyCFunction)Qt_TextMediaSetTextSampleData, 1, |
| "(MediaHandler mh, void * data, OSType dataType) -> (ComponentResult _rv)"}, |
| {"SpriteMediaSetProperty", (PyCFunction)Qt_SpriteMediaSetProperty, 1, |
| "(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)"}, |
| {"SpriteMediaGetProperty", (PyCFunction)Qt_SpriteMediaGetProperty, 1, |
| "(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)"}, |
| {"SpriteMediaHitTestSprites", (PyCFunction)Qt_SpriteMediaHitTestSprites, 1, |
| "(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, short spriteHitIndex)"}, |
| {"SpriteMediaCountSprites", (PyCFunction)Qt_SpriteMediaCountSprites, 1, |
| "(MediaHandler mh) -> (ComponentResult _rv, short numSprites)"}, |
| {"SpriteMediaCountImages", (PyCFunction)Qt_SpriteMediaCountImages, 1, |
| "(MediaHandler mh) -> (ComponentResult _rv, short numImages)"}, |
| {"SpriteMediaGetIndImageDescription", (PyCFunction)Qt_SpriteMediaGetIndImageDescription, 1, |
| "(MediaHandler mh, short imageIndex, ImageDescriptionHandle imageDescription) -> (ComponentResult _rv)"}, |
| {"SpriteMediaGetDisplayedSampleNumber", (PyCFunction)Qt_SpriteMediaGetDisplayedSampleNumber, 1, |
| "(MediaHandler mh) -> (ComponentResult _rv, long sampleNum)"}, |
| {"SpriteMediaGetSpriteName", (PyCFunction)Qt_SpriteMediaGetSpriteName, 1, |
| "(MediaHandler mh, QTAtomID spriteID, Str255 spriteName) -> (ComponentResult _rv)"}, |
| {"SpriteMediaGetImageName", (PyCFunction)Qt_SpriteMediaGetImageName, 1, |
| "(MediaHandler mh, short imageIndex, Str255 imageName) -> (ComponentResult _rv)"}, |
| {"SpriteMediaSetSpriteProperty", (PyCFunction)Qt_SpriteMediaSetSpriteProperty, 1, |
| "(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)"}, |
| {"SpriteMediaGetSpriteProperty", (PyCFunction)Qt_SpriteMediaGetSpriteProperty, 1, |
| "(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)"}, |
| {"SpriteMediaHitTestAllSprites", (PyCFunction)Qt_SpriteMediaHitTestAllSprites, 1, |
| "(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, QTAtomID spriteHitID)"}, |
| {"SpriteMediaHitTestOneSprite", (PyCFunction)Qt_SpriteMediaHitTestOneSprite, 1, |
| "(MediaHandler mh, QTAtomID spriteID, long flags, Point loc) -> (ComponentResult _rv, Boolean wasHit)"}, |
| {"SpriteMediaSpriteIndexToID", (PyCFunction)Qt_SpriteMediaSpriteIndexToID, 1, |
| "(MediaHandler mh, short spriteIndex) -> (ComponentResult _rv, QTAtomID spriteID)"}, |
| {"SpriteMediaSpriteIDToIndex", (PyCFunction)Qt_SpriteMediaSpriteIDToIndex, 1, |
| "(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv, short spriteIndex)"}, |
| {"SpriteMediaSetActionVariable", (PyCFunction)Qt_SpriteMediaSetActionVariable, 1, |
| "(MediaHandler mh, QTAtomID variableID, float value) -> (ComponentResult _rv)"}, |
| {"SpriteMediaGetActionVariable", (PyCFunction)Qt_SpriteMediaGetActionVariable, 1, |
| "(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, float value)"}, |
| {"SpriteMediaGetIndImageProperty", (PyCFunction)Qt_SpriteMediaGetIndImageProperty, 1, |
| "(MediaHandler mh, short imageIndex, long imagePropertyType, void * imagePropertyValue) -> (ComponentResult _rv)"}, |
| {"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1, |
| "() -> (TimeBase _rv)"}, |
| {"ConvertTime", (PyCFunction)Qt_ConvertTime, 1, |
| "(TimeRecord inout, TimeBase newBase) -> (TimeRecord inout)"}, |
| {"ConvertTimeScale", (PyCFunction)Qt_ConvertTimeScale, 1, |
| "(TimeRecord inout, TimeScale newScale) -> (TimeRecord inout)"}, |
| {"AddTime", (PyCFunction)Qt_AddTime, 1, |
| "(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)"}, |
| {"SubtractTime", (PyCFunction)Qt_SubtractTime, 1, |
| "(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)"}, |
| {"MusicMediaGetIndexedTunePlayer", (PyCFunction)Qt_MusicMediaGetIndexedTunePlayer, 1, |
| "(ComponentInstance ti, long sampleDescIndex) -> (ComponentResult _rv, ComponentInstance tp)"}, |
| {"AlignWindow", (PyCFunction)Qt_AlignWindow, 1, |
| "(WindowPtr wp, Boolean front) -> None"}, |
| {"DragAlignedWindow", (PyCFunction)Qt_DragAlignedWindow, 1, |
| "(WindowPtr wp, Point startPt, Rect boundsRect) -> None"}, |
| {"MoviesTask", (PyCFunction)Qt_MoviesTask, 1, |
| "(long maxMilliSecToUse) -> None"}, |
| {NULL, NULL, 0} |
| }; |
| |
| |
| |
| |
| void initQt() |
| { |
| PyObject *m; |
| PyObject *d; |
| |
| |
| |
| |
| m = Py_InitModule("Qt", Qt_methods); |
| d = PyModule_GetDict(m); |
| Qt_Error = PyMac_GetOSErrException(); |
| if (Qt_Error == NULL || |
| PyDict_SetItemString(d, "Error", Qt_Error) != 0) |
| Py_FatalError("can't initialize Qt.Error"); |
| MovieController_Type.ob_type = &PyType_Type; |
| Py_INCREF(&MovieController_Type); |
| if (PyDict_SetItemString(d, "MovieControllerType", (PyObject *)&MovieController_Type) != 0) |
| Py_FatalError("can't initialize MovieControllerType"); |
| TimeBase_Type.ob_type = &PyType_Type; |
| Py_INCREF(&TimeBase_Type); |
| if (PyDict_SetItemString(d, "TimeBaseType", (PyObject *)&TimeBase_Type) != 0) |
| Py_FatalError("can't initialize TimeBaseType"); |
| UserData_Type.ob_type = &PyType_Type; |
| Py_INCREF(&UserData_Type); |
| if (PyDict_SetItemString(d, "UserDataType", (PyObject *)&UserData_Type) != 0) |
| Py_FatalError("can't initialize UserDataType"); |
| Media_Type.ob_type = &PyType_Type; |
| Py_INCREF(&Media_Type); |
| if (PyDict_SetItemString(d, "MediaType", (PyObject *)&Media_Type) != 0) |
| Py_FatalError("can't initialize MediaType"); |
| Track_Type.ob_type = &PyType_Type; |
| Py_INCREF(&Track_Type); |
| if (PyDict_SetItemString(d, "TrackType", (PyObject *)&Track_Type) != 0) |
| Py_FatalError("can't initialize TrackType"); |
| Movie_Type.ob_type = &PyType_Type; |
| Py_INCREF(&Movie_Type); |
| if (PyDict_SetItemString(d, "MovieType", (PyObject *)&Movie_Type) != 0) |
| Py_FatalError("can't initialize MovieType"); |
| } |
| |
| /* ========================= End module Qt ========================== */ |
| |