/* =========================== Module Qt ============================ */ #include "Python.h" #include "macglue.h" #include "pymactoolbox.h" #include /* Macro to allow us to GetNextInterestingTime without duration */ #define GetMediaNextInterestingTimeOnly(media, flags, time, rate, rv) GetMediaNextInterestingTime(media, flags, time, rate, rv, NULL) /* ** Parse/generate time records */ static PyObject * QtTimeRecord_New(itself) TimeRecord *itself; { if (itself->base) return Py_BuildValue("O&lO&", PyMac_Buildwide, &itself->value, itself->scale, TimeBaseObj_New, itself->base); else return Py_BuildValue("O&lO", PyMac_Buildwide, &itself->value, itself->scale, Py_None); } static int QtTimeRecord_Convert(v, p_itself) PyObject *v; TimeRecord *p_itself; { PyObject *base = NULL; if( !PyArg_ParseTuple(v, "O&l|O", PyMac_Getwide, &p_itself->value, &p_itself->scale, &base) ) return 0; if ( base == NULL || base == Py_None ) p_itself->base = NULL; else if ( !TimeBaseObj_Convert(base, &p_itself->base) ) return 0; return 1; } static PyObject *Qt_Error; /* ------------------ Object type MovieController ------------------- */ PyTypeObject MovieController_Type; #define MovieCtlObj_Check(x) ((x)->ob_type == &MovieController_Type) 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_GetMediaDataSize64(_self, _args) MediaObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; TimeValue startTime; TimeValue duration; wide dataSize; if (!PyArg_ParseTuple(_args, "ll", &startTime, &duration)) return NULL; _err = GetMediaDataSize64(_self->ob_itself, startTime, duration, &dataSize); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("O&", PyMac_Buildwide, dataSize); return _res; } static PyObject *MediaObj_GetMediaNextInterestingTime(_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 PyObject *MediaObj_GetMediaNextInterestingTimeOnly(_self, _args) MediaObject *_self; PyObject *_args; { PyObject *_res = NULL; short interestingTimeFlags; TimeValue time; Fixed rate; TimeValue interestingTime; if (!PyArg_ParseTuple(_args, "hlO&", &interestingTimeFlags, &time, PyMac_GetFixed, &rate)) return NULL; GetMediaNextInterestingTimeOnly(_self->ob_itself, interestingTimeFlags, time, rate, &interestingTime); _res = Py_BuildValue("l", interestingTime); return _res; } static PyMethodDef MediaObj_methods[] = { {"LoadMediaIntoRam", (PyCFunction)MediaObj_LoadMediaIntoRam, 1, "(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)"}, {"GetMediaDataSize64", (PyCFunction)MediaObj_GetMediaDataSize64, 1, "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"}, {"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)"}, {"GetMediaNextInterestingTimeOnly", (PyCFunction)MediaObj_GetMediaNextInterestingTimeOnly, 1, "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime)"}, {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_GetTrackDataSize64(_self, _args) TrackObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; TimeValue startTime; TimeValue duration; wide dataSize; if (!PyArg_ParseTuple(_args, "ll", &startTime, &duration)) return NULL; _err = GetTrackDataSize64(_self->ob_itself, startTime, duration, &dataSize); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("O&", PyMac_Buildwide, dataSize); return _res; } static PyObject *TrackObj_PtInTrack(_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)"}, {"GetTrackDataSize64", (PyCFunction)TrackObj_GetTrackDataSize64, 1, "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"}, {"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_AbortPrePrerollMovie(_self, _args) MovieObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr err; if (!PyArg_ParseTuple(_args, "h", &err)) return NULL; AbortPrePrerollMovie(_self->ob_itself, err); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *MovieObj_LoadMovieIntoRam(_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_PutMovieIntoDataFork64(_self, _args) MovieObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; long fRefNum; wide offset; unsigned long maxSize; if (!PyArg_ParseTuple(_args, "lO&l", &fRefNum, PyMac_Getwide, &offset, &maxSize)) return NULL; _err = PutMovieIntoDataFork64(_self->ob_itself, fRefNum, &offset, maxSize); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *MovieObj_GetMovieCreationTime(_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_GetMovieDataSize64(_self, _args) MovieObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; TimeValue startTime; TimeValue duration; wide dataSize; if (!PyArg_ParseTuple(_args, "ll", &startTime, &duration)) return NULL; _err = GetMovieDataSize64(_self->ob_itself, startTime, duration, &dataSize); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("O&", PyMac_Buildwide, dataSize); return _res; } static PyObject *MovieObj_PtInMovie(_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_SetMovieAnchorDataRef(_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 = SetMovieAnchorDataRef(_self->ob_itself, dataRef, dataRefType); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *MovieObj_GetMovieAnchorDataRef(_self, _args) MovieObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; Handle dataRef; OSType dataRefType; long outFlags; if (!PyArg_ParseTuple(_args, "")) return NULL; _err = GetMovieAnchorDataRef(_self->ob_itself, &dataRef, &dataRefType, &outFlags); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("O&O&l", ResObj_New, dataRef, PyMac_BuildOSType, dataRefType, outFlags); 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_GetMovieLoadState(_self, _args) MovieObject *_self; PyObject *_args; { PyObject *_res = NULL; long _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetMovieLoadState(_self->ob_itself); _res = Py_BuildValue("l", _rv); 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"}, {"AbortPrePrerollMovie", (PyCFunction)MovieObj_AbortPrePrerollMovie, 1, "(OSErr err) -> 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"}, {"PutMovieIntoDataFork64", (PyCFunction)MovieObj_PutMovieIntoDataFork64, 1, "(long fRefNum, wide offset, unsigned 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)"}, {"GetMovieDataSize64", (PyCFunction)MovieObj_GetMovieDataSize64, 1, "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"}, {"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)"}, {"SetMovieAnchorDataRef", (PyCFunction)MovieObj_SetMovieAnchorDataRef, 1, "(Handle dataRef, OSType dataRefType) -> None"}, {"GetMovieAnchorDataRef", (PyCFunction)MovieObj_GetMovieAnchorDataRef, 1, "() -> (Handle dataRef, OSType dataRefType, long outFlags)"}, {"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)"}, {"GetMovieLoadState", (PyCFunction)MovieObj_GetMovieLoadState, 1, "() -> (long _rv)"}, {"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 ---------------------- */ #if !TARGET_API_MAC_CARBON 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; } #endif 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_OpenADataHandler(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; Handle dataRef; OSType dataHandlerSubType; Handle anchorDataRef; OSType anchorDataRefType; TimeBase tb; long flags; ComponentInstance dh; if (!PyArg_ParseTuple(_args, "O&O&O&O&O&l", ResObj_Convert, &dataRef, PyMac_GetOSType, &dataHandlerSubType, ResObj_Convert, &anchorDataRef, PyMac_GetOSType, &anchorDataRefType, TimeBaseObj_Convert, &tb, &flags)) return NULL; _err = OpenADataHandler(dataRef, dataHandlerSubType, anchorDataRef, anchorDataRefType, tb, flags, &dh); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("O&", CmpInstObj_New, dh); 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_NewMovieFromDataFork64(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; Movie theMovie; long fRefNum; wide fileOffset; short newMovieFlags; Boolean dataRefWasChanged; if (!PyArg_ParseTuple(_args, "lO&h", &fRefNum, PyMac_Getwide, &fileOffset, &newMovieFlags)) return NULL; _err = NewMovieFromDataFork64(&theMovie, fRefNum, &fileOffset, newMovieFlags, &dataRefWasChanged); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("O&b", MovieObj_New, theMovie, dataRefWasChanged); return _res; } static PyObject *Qt_NewMovieFromDataRef(_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_CreateShortcutMovieFile(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; FSSpec fileSpec; OSType creator; ScriptCode scriptTag; long createMovieFileFlags; Handle targetDataRef; OSType targetDataRefType; if (!PyArg_ParseTuple(_args, "O&O&hlO&O&", PyMac_GetFSSpec, &fileSpec, PyMac_GetOSType, &creator, &scriptTag, &createMovieFileFlags, ResObj_Convert, &targetDataRef, PyMac_GetOSType, &targetDataRefType)) return NULL; _err = CreateShortcutMovieFile(&fileSpec, creator, scriptTag, createMovieFileFlags, targetDataRef, targetDataRefType); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qt_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_VideoMediaSetCodecParameter(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; CodecType cType; OSType parameterID; long parameterChangeSeed; void * dataPtr; long dataSize; if (!PyArg_ParseTuple(_args, "O&O&O&lsl", CmpInstObj_Convert, &mh, PyMac_GetOSType, &cType, PyMac_GetOSType, ¶meterID, ¶meterChangeSeed, &dataPtr, &dataSize)) return NULL; _rv = VideoMediaSetCodecParameter(mh, cType, parameterID, parameterChangeSeed, dataPtr, dataSize); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_VideoMediaGetCodecParameter(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; CodecType cType; OSType parameterID; Handle outParameterData; if (!PyArg_ParseTuple(_args, "O&O&O&O&", CmpInstObj_Convert, &mh, PyMac_GetOSType, &cType, PyMac_GetOSType, ¶meterID, ResObj_Convert, &outParameterData)) return NULL; _rv = VideoMediaGetCodecParameter(mh, cType, parameterID, outParameterData); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_TextMediaAddTextSample(_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_TextMediaDrawRaw(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; GWorldPtr gw; GDHandle gd; void * data; long dataSize; TextDescriptionHandle tdh; if (!PyArg_ParseTuple(_args, "O&O&O&slO&", CmpInstObj_Convert, &mh, GWorldObj_Convert, &gw, OptResObj_Convert, &gd, &data, &dataSize, ResObj_Convert, &tdh)) return NULL; _rv = TextMediaDrawRaw(mh, gw, gd, data, dataSize, tdh); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_TextMediaSetTextProperty(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; TimeValue atMediaTime; long propertyType; void * data; long dataSize; if (!PyArg_ParseTuple(_args, "O&llsl", CmpInstObj_Convert, &mh, &atMediaTime, &propertyType, &data, &dataSize)) return NULL; _rv = TextMediaSetTextProperty(mh, atMediaTime, propertyType, data, dataSize); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_TextMediaRawSetup(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; GWorldPtr gw; GDHandle gd; void * data; long dataSize; TextDescriptionHandle tdh; TimeValue sampleDuration; if (!PyArg_ParseTuple(_args, "O&O&O&slO&l", CmpInstObj_Convert, &mh, GWorldObj_Convert, &gw, OptResObj_Convert, &gd, &data, &dataSize, ResObj_Convert, &tdh, &sampleDuration)) return NULL; _rv = TextMediaRawSetup(mh, gw, gd, data, dataSize, tdh, sampleDuration); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_TextMediaRawIdle(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; GWorldPtr gw; GDHandle gd; TimeValue sampleTime; long flagsIn; long flagsOut; if (!PyArg_ParseTuple(_args, "O&O&O&ll", CmpInstObj_Convert, &mh, GWorldObj_Convert, &gw, OptResObj_Convert, &gd, &sampleTime, &flagsIn)) return NULL; _rv = TextMediaRawIdle(mh, gw, gd, sampleTime, flagsIn, &flagsOut); _res = Py_BuildValue("ll", _rv, flagsOut); return _res; } static PyObject *Qt_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; } #if !TARGET_API_MAC_CARBON 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; } #endif static PyObject *Qt_SpriteMediaDisposeSprite(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; QTAtomID spriteID; if (!PyArg_ParseTuple(_args, "O&l", CmpInstObj_Convert, &mh, &spriteID)) return NULL; _rv = SpriteMediaDisposeSprite(mh, spriteID); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_SpriteMediaSetActionVariableToString(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; QTAtomID variableID; Ptr theCString; if (!PyArg_ParseTuple(_args, "O&ls", CmpInstObj_Convert, &mh, &variableID, &theCString)) return NULL; _rv = SpriteMediaSetActionVariableToString(mh, variableID, theCString); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_SpriteMediaGetActionVariableAsString(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; QTAtomID variableID; Handle theCString; if (!PyArg_ParseTuple(_args, "O&l", CmpInstObj_Convert, &mh, &variableID)) return NULL; _rv = SpriteMediaGetActionVariableAsString(mh, variableID, &theCString); _res = Py_BuildValue("lO&", _rv, ResObj_New, theCString); return _res; } static PyObject *Qt_FlashMediaSetPan(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; short xPercent; short yPercent; if (!PyArg_ParseTuple(_args, "O&hh", CmpInstObj_Convert, &mh, &xPercent, &yPercent)) return NULL; _rv = FlashMediaSetPan(mh, xPercent, yPercent); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_FlashMediaSetZoom(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; short factor; if (!PyArg_ParseTuple(_args, "O&h", CmpInstObj_Convert, &mh, &factor)) return NULL; _rv = FlashMediaSetZoom(mh, factor); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_FlashMediaSetZoomRect(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; long left; long top; long right; long bottom; if (!PyArg_ParseTuple(_args, "O&llll", CmpInstObj_Convert, &mh, &left, &top, &right, &bottom)) return NULL; _rv = FlashMediaSetZoomRect(mh, left, top, right, bottom); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_FlashMediaGetRefConBounds(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; long refCon; long left; long top; long right; long bottom; if (!PyArg_ParseTuple(_args, "O&l", CmpInstObj_Convert, &mh, &refCon)) return NULL; _rv = FlashMediaGetRefConBounds(mh, refCon, &left, &top, &right, &bottom); _res = Py_BuildValue("lllll", _rv, left, top, right, bottom); return _res; } static PyObject *Qt_FlashMediaGetRefConID(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; long refCon; long refConID; if (!PyArg_ParseTuple(_args, "O&l", CmpInstObj_Convert, &mh, &refCon)) return NULL; _rv = FlashMediaGetRefConID(mh, refCon, &refConID); _res = Py_BuildValue("ll", _rv, refConID); return _res; } static PyObject *Qt_FlashMediaIDToRefCon(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; long refConID; long refCon; if (!PyArg_ParseTuple(_args, "O&l", CmpInstObj_Convert, &mh, &refConID)) return NULL; _rv = FlashMediaIDToRefCon(mh, refConID, &refCon); _res = Py_BuildValue("ll", _rv, refCon); return _res; } static PyObject *Qt_FlashMediaGetDisplayedFrameNumber(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; long flashFrameNumber; if (!PyArg_ParseTuple(_args, "O&", CmpInstObj_Convert, &mh)) return NULL; _rv = FlashMediaGetDisplayedFrameNumber(mh, &flashFrameNumber); _res = Py_BuildValue("ll", _rv, flashFrameNumber); return _res; } static PyObject *Qt_FlashMediaFrameNumberToMovieTime(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; long flashFrameNumber; TimeValue movieTime; if (!PyArg_ParseTuple(_args, "O&l", CmpInstObj_Convert, &mh, &flashFrameNumber)) return NULL; _rv = FlashMediaFrameNumberToMovieTime(mh, flashFrameNumber, &movieTime); _res = Py_BuildValue("ll", _rv, movieTime); return _res; } static PyObject *Qt_FlashMediaFrameLabelToMovieTime(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; Ptr theLabel; TimeValue movieTime; if (!PyArg_ParseTuple(_args, "O&s", CmpInstObj_Convert, &mh, &theLabel)) return NULL; _rv = FlashMediaFrameLabelToMovieTime(mh, theLabel, &movieTime); _res = Py_BuildValue("ll", _rv, movieTime); return _res; } static PyObject *Qt_MovieMediaGetCurrentMovieProperty(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; OSType whichProperty; void * value; if (!PyArg_ParseTuple(_args, "O&O&s", CmpInstObj_Convert, &mh, PyMac_GetOSType, &whichProperty, &value)) return NULL; _rv = MovieMediaGetCurrentMovieProperty(mh, whichProperty, value); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_MovieMediaGetCurrentTrackProperty(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; long trackID; OSType whichProperty; void * value; if (!PyArg_ParseTuple(_args, "O&lO&s", CmpInstObj_Convert, &mh, &trackID, PyMac_GetOSType, &whichProperty, &value)) return NULL; _rv = MovieMediaGetCurrentTrackProperty(mh, trackID, whichProperty, value); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_MovieMediaGetChildMovieDataReference(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; QTAtomID dataRefID; short dataRefIndex; OSType dataRefType; Handle dataRef; QTAtomID dataRefIDOut; short dataRefIndexOut; if (!PyArg_ParseTuple(_args, "O&lh", CmpInstObj_Convert, &mh, &dataRefID, &dataRefIndex)) return NULL; _rv = MovieMediaGetChildMovieDataReference(mh, dataRefID, dataRefIndex, &dataRefType, &dataRef, &dataRefIDOut, &dataRefIndexOut); _res = Py_BuildValue("lO&O&lh", _rv, PyMac_BuildOSType, dataRefType, ResObj_New, dataRef, dataRefIDOut, dataRefIndexOut); return _res; } static PyObject *Qt_MovieMediaSetChildMovieDataReference(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; QTAtomID dataRefID; OSType dataRefType; Handle dataRef; if (!PyArg_ParseTuple(_args, "O&lO&O&", CmpInstObj_Convert, &mh, &dataRefID, PyMac_GetOSType, &dataRefType, ResObj_Convert, &dataRef)) return NULL; _rv = MovieMediaSetChildMovieDataReference(mh, dataRefID, dataRefType, dataRef); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_MovieMediaLoadChildMovieFromDataReference(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; QTAtomID dataRefID; if (!PyArg_ParseTuple(_args, "O&l", CmpInstObj_Convert, &mh, &dataRefID)) return NULL; _rv = MovieMediaLoadChildMovieFromDataReference(mh, dataRefID); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_Media3DGetCurrentGroup(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; void * group; if (!PyArg_ParseTuple(_args, "O&s", CmpInstObj_Convert, &mh, &group)) return NULL; _rv = Media3DGetCurrentGroup(mh, group); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_Media3DTranslateNamedObjectTo(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; char objectName; Fixed x; Fixed y; Fixed z; if (!PyArg_ParseTuple(_args, "O&O&O&O&", CmpInstObj_Convert, &mh, PyMac_GetFixed, &x, PyMac_GetFixed, &y, PyMac_GetFixed, &z)) return NULL; _rv = Media3DTranslateNamedObjectTo(mh, &objectName, x, y, z); _res = Py_BuildValue("lc", _rv, objectName); return _res; } static PyObject *Qt_Media3DScaleNamedObjectTo(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; char objectName; Fixed xScale; Fixed yScale; Fixed zScale; if (!PyArg_ParseTuple(_args, "O&O&O&O&", CmpInstObj_Convert, &mh, PyMac_GetFixed, &xScale, PyMac_GetFixed, &yScale, PyMac_GetFixed, &zScale)) return NULL; _rv = Media3DScaleNamedObjectTo(mh, &objectName, xScale, yScale, zScale); _res = Py_BuildValue("lc", _rv, objectName); return _res; } static PyObject *Qt_Media3DRotateNamedObjectTo(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; char objectName; Fixed xDegrees; Fixed yDegrees; Fixed zDegrees; if (!PyArg_ParseTuple(_args, "O&O&O&O&", CmpInstObj_Convert, &mh, PyMac_GetFixed, &xDegrees, PyMac_GetFixed, &yDegrees, PyMac_GetFixed, &zDegrees)) return NULL; _rv = Media3DRotateNamedObjectTo(mh, &objectName, xDegrees, yDegrees, zDegrees); _res = Py_BuildValue("lc", _rv, objectName); return _res; } static PyObject *Qt_Media3DSetCameraData(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; void * cameraData; if (!PyArg_ParseTuple(_args, "O&s", CmpInstObj_Convert, &mh, &cameraData)) return NULL; _rv = Media3DSetCameraData(mh, cameraData); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_Media3DGetCameraData(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; void * cameraData; if (!PyArg_ParseTuple(_args, "O&s", CmpInstObj_Convert, &mh, &cameraData)) return NULL; _rv = Media3DGetCameraData(mh, cameraData); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_Media3DSetCameraAngleAspect(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; QTFloatSingle fov; QTFloatSingle aspectRatioXToY; if (!PyArg_ParseTuple(_args, "O&ff", CmpInstObj_Convert, &mh, &fov, &aspectRatioXToY)) return NULL; _rv = Media3DSetCameraAngleAspect(mh, fov, aspectRatioXToY); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_Media3DGetCameraAngleAspect(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; QTFloatSingle fov; QTFloatSingle aspectRatioXToY; if (!PyArg_ParseTuple(_args, "O&", CmpInstObj_Convert, &mh)) return NULL; _rv = Media3DGetCameraAngleAspect(mh, &fov, &aspectRatioXToY); _res = Py_BuildValue("lff", _rv, fov, aspectRatioXToY); return _res; } static PyObject *Qt_Media3DSetCameraRange(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; void * tQ3CameraRange; if (!PyArg_ParseTuple(_args, "O&s", CmpInstObj_Convert, &mh, &tQ3CameraRange)) return NULL; _rv = Media3DSetCameraRange(mh, tQ3CameraRange); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_Media3DGetCameraRange(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; void * tQ3CameraRange; if (!PyArg_ParseTuple(_args, "O&s", CmpInstObj_Convert, &mh, &tQ3CameraRange)) return NULL; _rv = Media3DGetCameraRange(mh, tQ3CameraRange); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qt_Media3DGetViewObject(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; ComponentResult _rv; MediaHandler mh; void * tq3viewObject; if (!PyArg_ParseTuple(_args, "O&s", CmpInstObj_Convert, &mh, &tq3viewObject)) return NULL; _rv = Media3DGetViewObject(mh, tq3viewObject); _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[] = { #if !TARGET_API_MAC_CARBON {"CheckQuickTimeRegistration", (PyCFunction)Qt_CheckQuickTimeRegistration, 1, "(void * registrationKey, long flags) -> None"}, #endif {"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)"}, {"OpenADataHandler", (PyCFunction)Qt_OpenADataHandler, 1, "(Handle dataRef, OSType dataHandlerSubType, Handle anchorDataRef, OSType anchorDataRefType, TimeBase tb, long flags) -> (ComponentInstance dh)"}, {"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)"}, {"NewMovieFromDataFork64", (PyCFunction)Qt_NewMovieFromDataFork64, 1, "(long fRefNum, wide 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"}, {"CreateShortcutMovieFile", (PyCFunction)Qt_CreateShortcutMovieFile, 1, "(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Handle targetDataRef, OSType targetDataRefType) -> 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)"}, {"VideoMediaSetCodecParameter", (PyCFunction)Qt_VideoMediaSetCodecParameter, 1, "(MediaHandler mh, CodecType cType, OSType parameterID, long parameterChangeSeed, void * dataPtr, long dataSize) -> (ComponentResult _rv)"}, {"VideoMediaGetCodecParameter", (PyCFunction)Qt_VideoMediaGetCodecParameter, 1, "(MediaHandler mh, CodecType cType, OSType parameterID, Handle outParameterData) -> (ComponentResult _rv)"}, {"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)"}, {"TextMediaDrawRaw", (PyCFunction)Qt_TextMediaDrawRaw, 1, "(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh) -> (ComponentResult _rv)"}, {"TextMediaSetTextProperty", (PyCFunction)Qt_TextMediaSetTextProperty, 1, "(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)"}, {"TextMediaRawSetup", (PyCFunction)Qt_TextMediaRawSetup, 1, "(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh, TimeValue sampleDuration) -> (ComponentResult _rv)"}, {"TextMediaRawIdle", (PyCFunction)Qt_TextMediaRawIdle, 1, "(MediaHandler mh, GWorldPtr gw, GDHandle gd, TimeValue sampleTime, long flagsIn) -> (ComponentResult _rv, long flagsOut)"}, {"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)"}, #if !TARGET_API_MAC_CARBON {"SpriteMediaGetIndImageProperty", (PyCFunction)Qt_SpriteMediaGetIndImageProperty, 1, "(MediaHandler mh, short imageIndex, long imagePropertyType, void * imagePropertyValue) -> (ComponentResult _rv)"}, #endif {"SpriteMediaDisposeSprite", (PyCFunction)Qt_SpriteMediaDisposeSprite, 1, "(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv)"}, {"SpriteMediaSetActionVariableToString", (PyCFunction)Qt_SpriteMediaSetActionVariableToString, 1, "(MediaHandler mh, QTAtomID variableID, Ptr theCString) -> (ComponentResult _rv)"}, {"SpriteMediaGetActionVariableAsString", (PyCFunction)Qt_SpriteMediaGetActionVariableAsString, 1, "(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, Handle theCString)"}, {"FlashMediaSetPan", (PyCFunction)Qt_FlashMediaSetPan, 1, "(MediaHandler mh, short xPercent, short yPercent) -> (ComponentResult _rv)"}, {"FlashMediaSetZoom", (PyCFunction)Qt_FlashMediaSetZoom, 1, "(MediaHandler mh, short factor) -> (ComponentResult _rv)"}, {"FlashMediaSetZoomRect", (PyCFunction)Qt_FlashMediaSetZoomRect, 1, "(MediaHandler mh, long left, long top, long right, long bottom) -> (ComponentResult _rv)"}, {"FlashMediaGetRefConBounds", (PyCFunction)Qt_FlashMediaGetRefConBounds, 1, "(MediaHandler mh, long refCon) -> (ComponentResult _rv, long left, long top, long right, long bottom)"}, {"FlashMediaGetRefConID", (PyCFunction)Qt_FlashMediaGetRefConID, 1, "(MediaHandler mh, long refCon) -> (ComponentResult _rv, long refConID)"}, {"FlashMediaIDToRefCon", (PyCFunction)Qt_FlashMediaIDToRefCon, 1, "(MediaHandler mh, long refConID) -> (ComponentResult _rv, long refCon)"}, {"FlashMediaGetDisplayedFrameNumber", (PyCFunction)Qt_FlashMediaGetDisplayedFrameNumber, 1, "(MediaHandler mh) -> (ComponentResult _rv, long flashFrameNumber)"}, {"FlashMediaFrameNumberToMovieTime", (PyCFunction)Qt_FlashMediaFrameNumberToMovieTime, 1, "(MediaHandler mh, long flashFrameNumber) -> (ComponentResult _rv, TimeValue movieTime)"}, {"FlashMediaFrameLabelToMovieTime", (PyCFunction)Qt_FlashMediaFrameLabelToMovieTime, 1, "(MediaHandler mh, Ptr theLabel) -> (ComponentResult _rv, TimeValue movieTime)"}, {"MovieMediaGetCurrentMovieProperty", (PyCFunction)Qt_MovieMediaGetCurrentMovieProperty, 1, "(MediaHandler mh, OSType whichProperty, void * value) -> (ComponentResult _rv)"}, {"MovieMediaGetCurrentTrackProperty", (PyCFunction)Qt_MovieMediaGetCurrentTrackProperty, 1, "(MediaHandler mh, long trackID, OSType whichProperty, void * value) -> (ComponentResult _rv)"}, {"MovieMediaGetChildMovieDataReference", (PyCFunction)Qt_MovieMediaGetChildMovieDataReference, 1, "(MediaHandler mh, QTAtomID dataRefID, short dataRefIndex) -> (ComponentResult _rv, OSType dataRefType, Handle dataRef, QTAtomID dataRefIDOut, short dataRefIndexOut)"}, {"MovieMediaSetChildMovieDataReference", (PyCFunction)Qt_MovieMediaSetChildMovieDataReference, 1, "(MediaHandler mh, QTAtomID dataRefID, OSType dataRefType, Handle dataRef) -> (ComponentResult _rv)"}, {"MovieMediaLoadChildMovieFromDataReference", (PyCFunction)Qt_MovieMediaLoadChildMovieFromDataReference, 1, "(MediaHandler mh, QTAtomID dataRefID) -> (ComponentResult _rv)"}, {"Media3DGetCurrentGroup", (PyCFunction)Qt_Media3DGetCurrentGroup, 1, "(MediaHandler mh, void * group) -> (ComponentResult _rv)"}, {"Media3DTranslateNamedObjectTo", (PyCFunction)Qt_Media3DTranslateNamedObjectTo, 1, "(MediaHandler mh, Fixed x, Fixed y, Fixed z) -> (ComponentResult _rv, char objectName)"}, {"Media3DScaleNamedObjectTo", (PyCFunction)Qt_Media3DScaleNamedObjectTo, 1, "(MediaHandler mh, Fixed xScale, Fixed yScale, Fixed zScale) -> (ComponentResult _rv, char objectName)"}, {"Media3DRotateNamedObjectTo", (PyCFunction)Qt_Media3DRotateNamedObjectTo, 1, "(MediaHandler mh, Fixed xDegrees, Fixed yDegrees, Fixed zDegrees) -> (ComponentResult _rv, char objectName)"}, {"Media3DSetCameraData", (PyCFunction)Qt_Media3DSetCameraData, 1, "(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)"}, {"Media3DGetCameraData", (PyCFunction)Qt_Media3DGetCameraData, 1, "(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)"}, {"Media3DSetCameraAngleAspect", (PyCFunction)Qt_Media3DSetCameraAngleAspect, 1, "(MediaHandler mh, QTFloatSingle fov, QTFloatSingle aspectRatioXToY) -> (ComponentResult _rv)"}, {"Media3DGetCameraAngleAspect", (PyCFunction)Qt_Media3DGetCameraAngleAspect, 1, "(MediaHandler mh) -> (ComponentResult _rv, QTFloatSingle fov, QTFloatSingle aspectRatioXToY)"}, {"Media3DSetCameraRange", (PyCFunction)Qt_Media3DSetCameraRange, 1, "(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)"}, {"Media3DGetCameraRange", (PyCFunction)Qt_Media3DGetCameraRange, 1, "(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)"}, {"Media3DGetViewObject", (PyCFunction)Qt_Media3DGetViewObject, 1, "(MediaHandler mh, void * tq3viewObject) -> (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) return; 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 ========================== */