summaryrefslogtreecommitdiffstats
path: root/Mac
diff options
context:
space:
mode:
Diffstat (limited to 'Mac')
-rw-r--r--Mac/Modules/qt/_Qtmodule.c806
-rw-r--r--Mac/Modules/qt/qtscan.py7
-rw-r--r--Mac/Modules/qt/qtsupport.py11
3 files changed, 819 insertions, 5 deletions
diff --git a/Mac/Modules/qt/_Qtmodule.c b/Mac/Modules/qt/_Qtmodule.c
index 9fc9be2..69ada2e 100644
--- a/Mac/Modules/qt/_Qtmodule.c
+++ b/Mac/Modules/qt/_Qtmodule.c
@@ -83,6 +83,124 @@ QtTimeRecord_Convert(PyObject *v, TimeRecord *p_itself)
static PyObject *Qt_Error;
+/* -------------------- Object type IdleManager --------------------- */
+
+PyTypeObject IdleManager_Type;
+
+#define IdleManagerObj_Check(x) ((x)->ob_type == &IdleManager_Type || PyObject_TypeCheck((x), &IdleManager_Type))
+
+typedef struct IdleManagerObject {
+ PyObject_HEAD
+ IdleManager ob_itself;
+} IdleManagerObject;
+
+PyObject *IdleManagerObj_New(IdleManager itself)
+{
+ IdleManagerObject *it;
+ if (itself == NULL) {
+ PyErr_SetString(Qt_Error,"Cannot create null IdleManager");
+ return NULL;
+ }
+ it = PyObject_NEW(IdleManagerObject, &IdleManager_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+int IdleManagerObj_Convert(PyObject *v, IdleManager *p_itself)
+{
+ if (!IdleManagerObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "IdleManager required");
+ return 0;
+ }
+ *p_itself = ((IdleManagerObject *)v)->ob_itself;
+ return 1;
+}
+
+static void IdleManagerObj_dealloc(IdleManagerObject *self)
+{
+ /* Cleanup of self->ob_itself goes here */
+ self->ob_type->tp_free((PyObject *)self);
+}
+
+static PyMethodDef IdleManagerObj_methods[] = {
+ {NULL, NULL, 0}
+};
+
+#define IdleManagerObj_getsetlist NULL
+
+
+#define IdleManagerObj_compare NULL
+
+#define IdleManagerObj_repr NULL
+
+#define IdleManagerObj_hash NULL
+#define IdleManagerObj_tp_init 0
+
+#define IdleManagerObj_tp_alloc PyType_GenericAlloc
+
+static PyObject *IdleManagerObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+ PyObject *self;
+ IdleManager itself;
+ char *kw[] = {"itself", 0};
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, IdleManagerObj_Convert, &itself)) return NULL;
+ if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
+ ((IdleManagerObject *)self)->ob_itself = itself;
+ return self;
+}
+
+#define IdleManagerObj_tp_free PyObject_Del
+
+
+PyTypeObject IdleManager_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0, /*ob_size*/
+ "_Qt.IdleManager", /*tp_name*/
+ sizeof(IdleManagerObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) IdleManagerObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc)0, /*tp_getattr*/
+ (setattrfunc)0, /*tp_setattr*/
+ (cmpfunc) IdleManagerObj_compare, /*tp_compare*/
+ (reprfunc) IdleManagerObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) IdleManagerObj_hash, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ PyObject_GenericGetAttr, /*tp_getattro*/
+ PyObject_GenericSetAttr, /*tp_setattro */
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
+ 0, /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ 0, /*tp_iter*/
+ 0, /*tp_iternext*/
+ IdleManagerObj_methods, /* tp_methods */
+ 0, /*tp_members*/
+ IdleManagerObj_getsetlist, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ IdleManagerObj_tp_init, /* tp_init */
+ IdleManagerObj_tp_alloc, /* tp_alloc */
+ IdleManagerObj_tp_new, /* tp_new */
+ IdleManagerObj_tp_free, /* tp_free */
+};
+
+/* ------------------ End object type IdleManager ------------------- */
+
+
/* ------------------ Object type MovieController ------------------- */
PyTypeObject MovieController_Type;
@@ -984,6 +1102,45 @@ static PyObject *MovieCtlObj_MCTrimMovieSegment(MovieControllerObject *_self, Py
return _res;
}
+static PyObject *MovieCtlObj_MCSetIdleManager(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ IdleManager im;
+#ifndef MCSetIdleManager
+ PyMac_PRECHECK(MCSetIdleManager);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ IdleManagerObj_Convert, &im))
+ return NULL;
+ _rv = MCSetIdleManager(_self->ob_itself,
+ im);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCSetControllerCapabilities(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ long flags;
+ long flagsMask;
+#ifndef MCSetControllerCapabilities
+ PyMac_PRECHECK(MCSetControllerCapabilities);
+#endif
+ if (!PyArg_ParseTuple(_args, "ll",
+ &flags,
+ &flagsMask))
+ return NULL;
+ _rv = MCSetControllerCapabilities(_self->ob_itself,
+ flags,
+ flagsMask);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
static PyMethodDef MovieCtlObj_methods[] = {
{"MCSetMovie", (PyCFunction)MovieCtlObj_MCSetMovie, 1,
PyDoc_STR("(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)")},
@@ -1077,6 +1234,10 @@ static PyMethodDef MovieCtlObj_methods[] = {
PyDoc_STR("(Movie srcMovie, Boolean scaled) -> (ComponentResult _rv)")},
{"MCTrimMovieSegment", (PyCFunction)MovieCtlObj_MCTrimMovieSegment, 1,
PyDoc_STR("() -> (ComponentResult _rv)")},
+ {"MCSetIdleManager", (PyCFunction)MovieCtlObj_MCSetIdleManager, 1,
+ PyDoc_STR("(IdleManager im) -> (ComponentResult _rv)")},
+ {"MCSetControllerCapabilities", (PyCFunction)MovieCtlObj_MCSetControllerCapabilities, 1,
+ PyDoc_STR("(long flags, long flagsMask) -> (ComponentResult _rv)")},
{NULL, NULL, 0}
};
@@ -1887,6 +2048,28 @@ static PyObject *UserDataObj_PutUserDataIntoHandle(UserDataObject *_self, PyObje
return _res;
}
+static PyObject *UserDataObj_CopyUserData(UserDataObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ UserData dstUserData;
+ OSType copyRule;
+#ifndef CopyUserData
+ PyMac_PRECHECK(CopyUserData);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ UserDataObj_Convert, &dstUserData,
+ PyMac_GetOSType, &copyRule))
+ return NULL;
+ _err = CopyUserData(_self->ob_itself,
+ dstUserData,
+ copyRule);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyMethodDef UserDataObj_methods[] = {
{"GetUserData", (PyCFunction)UserDataObj_GetUserData, 1,
PyDoc_STR("(Handle data, OSType udType, long index) -> None")},
@@ -1906,6 +2089,8 @@ static PyMethodDef UserDataObj_methods[] = {
PyDoc_STR("(OSType udType, long index, short itlRegionTag) -> None")},
{"PutUserDataIntoHandle", (PyCFunction)UserDataObj_PutUserDataIntoHandle, 1,
PyDoc_STR("(Handle h) -> None")},
+ {"CopyUserData", (PyCFunction)UserDataObj_CopyUserData, 1,
+ PyDoc_STR("(UserData dstUserData, OSType copyRule) -> None")},
{NULL, NULL, 0}
};
@@ -2818,6 +3003,28 @@ static PyObject *MediaObj_GetMediaDataSize64(MediaObject *_self, PyObject *_args
return _res;
}
+static PyObject *MediaObj_CopyMediaUserData(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Media dstMedia;
+ OSType copyRule;
+#ifndef CopyMediaUserData
+ PyMac_PRECHECK(CopyMediaUserData);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ MediaObj_Convert, &dstMedia,
+ PyMac_GetOSType, &copyRule))
+ return NULL;
+ _err = CopyMediaUserData(_self->ob_itself,
+ dstMedia,
+ copyRule);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *MediaObj_GetMediaNextInterestingTime(MediaObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -3100,6 +3307,8 @@ static PyMethodDef MediaObj_methods[] = {
PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")},
{"GetMediaDataSize64", (PyCFunction)MediaObj_GetMediaDataSize64, 1,
PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")},
+ {"CopyMediaUserData", (PyCFunction)MediaObj_CopyMediaUserData, 1,
+ PyDoc_STR("(Media dstMedia, OSType copyRule) -> None")},
{"GetMediaNextInterestingTime", (PyCFunction)MediaObj_GetMediaNextInterestingTime, 1,
PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
{"GetMediaDataRef", (PyCFunction)MediaObj_GetMediaDataRef, 1,
@@ -4206,6 +4415,28 @@ static PyObject *TrackObj_PtInTrack(TrackObject *_self, PyObject *_args)
return _res;
}
+static PyObject *TrackObj_CopyTrackUserData(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Track dstTrack;
+ OSType copyRule;
+#ifndef CopyTrackUserData
+ PyMac_PRECHECK(CopyTrackUserData);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ TrackObj_Convert, &dstTrack,
+ PyMac_GetOSType, &copyRule))
+ return NULL;
+ _err = CopyTrackUserData(_self->ob_itself,
+ dstTrack,
+ copyRule);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *TrackObj_GetTrackNextInterestingTime(TrackObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -4426,6 +4657,8 @@ static PyMethodDef TrackObj_methods[] = {
PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")},
{"PtInTrack", (PyCFunction)TrackObj_PtInTrack, 1,
PyDoc_STR("(Point pt) -> (Boolean _rv)")},
+ {"CopyTrackUserData", (PyCFunction)TrackObj_CopyTrackUserData, 1,
+ PyDoc_STR("(Track dstTrack, OSType copyRule) -> None")},
{"GetTrackNextInterestingTime", (PyCFunction)TrackObj_GetTrackNextInterestingTime, 1,
PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
{"GetTrackSegmentDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackSegmentDisplayBoundsRgn, 1,
@@ -4838,6 +5071,23 @@ static PyObject *MovieObj_SetMovieMasterClock(MovieObject *_self, PyObject *_arg
return _res;
}
+static PyObject *MovieObj_ChooseMovieClock(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long flags;
+#ifndef ChooseMovieClock
+ PyMac_PRECHECK(ChooseMovieClock);
+#endif
+ if (!PyArg_ParseTuple(_args, "l",
+ &flags))
+ return NULL;
+ ChooseMovieClock(_self->ob_itself,
+ flags);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *MovieObj_GetMovieGWorld(MovieObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -5210,6 +5460,56 @@ static PyObject *MovieObj_PutMovieIntoDataFork64(MovieObject *_self, PyObject *_
return _res;
}
+static PyObject *MovieObj_PutMovieIntoStorage(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ DataHandler dh;
+ wide offset;
+ unsigned long maxSize;
+#ifndef PutMovieIntoStorage
+ PyMac_PRECHECK(PutMovieIntoStorage);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ CmpInstObj_Convert, &dh,
+ PyMac_Getwide, &offset,
+ &maxSize))
+ return NULL;
+ _err = PutMovieIntoStorage(_self->ob_itself,
+ dh,
+ &offset,
+ maxSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_PutMovieForDataRefIntoHandle(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataRef;
+ OSType dataRefType;
+ Handle publicMovie;
+#ifndef PutMovieForDataRefIntoHandle
+ PyMac_PRECHECK(PutMovieForDataRefIntoHandle);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType,
+ ResObj_Convert, &publicMovie))
+ return NULL;
+ _err = PutMovieForDataRefIntoHandle(_self->ob_itself,
+ dataRef,
+ dataRefType,
+ publicMovie);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *MovieObj_GetMovieCreationTime(MovieObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -6111,6 +6411,28 @@ static PyObject *MovieObj_SetMovieLanguage(MovieObject *_self, PyObject *_args)
return _res;
}
+static PyObject *MovieObj_CopyMovieUserData(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Movie dstMovie;
+ OSType copyRule;
+#ifndef CopyMovieUserData
+ PyMac_PRECHECK(CopyMovieUserData);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ MovieObj_Convert, &dstMovie,
+ PyMac_GetOSType, &copyRule))
+ return NULL;
+ _err = CopyMovieUserData(_self->ob_itself,
+ dstMovie,
+ copyRule);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *MovieObj_GetMovieNextInterestingTime(MovieObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -6194,6 +6516,44 @@ static PyObject *MovieObj_UpdateMovieResource(MovieObject *_self, PyObject *_arg
return _res;
}
+static PyObject *MovieObj_AddMovieToStorage(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ DataHandler dh;
+#ifndef AddMovieToStorage
+ PyMac_PRECHECK(AddMovieToStorage);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &dh))
+ return NULL;
+ _err = AddMovieToStorage(_self->ob_itself,
+ dh);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_UpdateMovieInStorage(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ DataHandler dh;
+#ifndef UpdateMovieInStorage
+ PyMac_PRECHECK(UpdateMovieInStorage);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &dh))
+ return NULL;
+ _err = UpdateMovieInStorage(_self->ob_itself,
+ dh);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *MovieObj_HasMovieChanged(MovieObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -6367,6 +6727,39 @@ static PyObject *MovieObj_FlattenMovieData(MovieObject *_self, PyObject *_args)
return _res;
}
+static PyObject *MovieObj_FlattenMovieDataToDataRef(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Movie _rv;
+ long movieFlattenFlags;
+ Handle dataRef;
+ OSType dataRefType;
+ OSType creator;
+ ScriptCode scriptTag;
+ long createMovieFileFlags;
+#ifndef FlattenMovieDataToDataRef
+ PyMac_PRECHECK(FlattenMovieDataToDataRef);
+#endif
+ if (!PyArg_ParseTuple(_args, "lO&O&O&hl",
+ &movieFlattenFlags,
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType,
+ PyMac_GetOSType, &creator,
+ &scriptTag,
+ &createMovieFileFlags))
+ return NULL;
+ _rv = FlattenMovieDataToDataRef(_self->ob_itself,
+ movieFlattenFlags,
+ dataRef,
+ dataRefType,
+ creator,
+ scriptTag,
+ createMovieFileFlags);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
+ return _res;
+}
+
static PyObject *MovieObj_MovieSearchText(MovieObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -6627,6 +7020,8 @@ static PyMethodDef MovieObj_methods[] = {
PyDoc_STR("(TimeBase tb, TimeRecord slaveZero) -> None")},
{"SetMovieMasterClock", (PyCFunction)MovieObj_SetMovieMasterClock, 1,
PyDoc_STR("(Component clockMeister, TimeRecord slaveZero) -> None")},
+ {"ChooseMovieClock", (PyCFunction)MovieObj_ChooseMovieClock, 1,
+ PyDoc_STR("(long flags) -> None")},
{"GetMovieGWorld", (PyCFunction)MovieObj_GetMovieGWorld, 1,
PyDoc_STR("() -> (CGrafPtr port, GDHandle gdh)")},
{"SetMovieGWorld", (PyCFunction)MovieObj_SetMovieGWorld, 1,
@@ -6669,6 +7064,10 @@ static PyMethodDef MovieObj_methods[] = {
PyDoc_STR("(short fRefNum, long offset, long maxSize) -> None")},
{"PutMovieIntoDataFork64", (PyCFunction)MovieObj_PutMovieIntoDataFork64, 1,
PyDoc_STR("(long fRefNum, wide offset, unsigned long maxSize) -> None")},
+ {"PutMovieIntoStorage", (PyCFunction)MovieObj_PutMovieIntoStorage, 1,
+ PyDoc_STR("(DataHandler dh, wide offset, unsigned long maxSize) -> None")},
+ {"PutMovieForDataRefIntoHandle", (PyCFunction)MovieObj_PutMovieForDataRefIntoHandle, 1,
+ PyDoc_STR("(Handle dataRef, OSType dataRefType, Handle publicMovie) -> None")},
{"GetMovieCreationTime", (PyCFunction)MovieObj_GetMovieCreationTime, 1,
PyDoc_STR("() -> (unsigned long _rv)")},
{"GetMovieModificationTime", (PyCFunction)MovieObj_GetMovieModificationTime, 1,
@@ -6765,12 +7164,18 @@ static PyMethodDef MovieObj_methods[] = {
PyDoc_STR("(Point pt) -> (Boolean _rv)")},
{"SetMovieLanguage", (PyCFunction)MovieObj_SetMovieLanguage, 1,
PyDoc_STR("(long language) -> None")},
+ {"CopyMovieUserData", (PyCFunction)MovieObj_CopyMovieUserData, 1,
+ PyDoc_STR("(Movie dstMovie, OSType copyRule) -> None")},
{"GetMovieNextInterestingTime", (PyCFunction)MovieObj_GetMovieNextInterestingTime, 1,
PyDoc_STR("(short interestingTimeFlags, short numMediaTypes, OSType whichMediaTypes, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
{"AddMovieResource", (PyCFunction)MovieObj_AddMovieResource, 1,
PyDoc_STR("(short resRefNum, Str255 resName) -> (short resId)")},
{"UpdateMovieResource", (PyCFunction)MovieObj_UpdateMovieResource, 1,
PyDoc_STR("(short resRefNum, short resId, Str255 resName) -> None")},
+ {"AddMovieToStorage", (PyCFunction)MovieObj_AddMovieToStorage, 1,
+ PyDoc_STR("(DataHandler dh) -> None")},
+ {"UpdateMovieInStorage", (PyCFunction)MovieObj_UpdateMovieInStorage, 1,
+ PyDoc_STR("(DataHandler dh) -> None")},
{"HasMovieChanged", (PyCFunction)MovieObj_HasMovieChanged, 1,
PyDoc_STR("() -> (Boolean _rv)")},
{"ClearMovieChanged", (PyCFunction)MovieObj_ClearMovieChanged, 1,
@@ -6787,6 +7192,8 @@ static PyMethodDef MovieObj_methods[] = {
PyDoc_STR("(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Str255 resName) -> (short resId)")},
{"FlattenMovieData", (PyCFunction)MovieObj_FlattenMovieData, 1,
PyDoc_STR("(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)")},
+ {"FlattenMovieDataToDataRef", (PyCFunction)MovieObj_FlattenMovieDataToDataRef, 1,
+ PyDoc_STR("(long movieFlattenFlags, Handle dataRef, OSType dataRefType, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)")},
{"MovieSearchText", (PyCFunction)MovieObj_MovieSearchText, 1,
PyDoc_STR("(Ptr text, long size, long searchFlags) -> (Track searchTrack, TimeValue searchTime, long searchOffset)")},
{"GetPosterBox", (PyCFunction)MovieObj_GetPosterBox, 1,
@@ -6962,6 +7369,67 @@ static PyObject *Qt_GetMoviesStickyError(PyObject *_self, PyObject *_args)
return _res;
}
+static PyObject *Qt_QTGetWallClockTimeBase(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeBase wallClockTimeBase;
+#ifndef QTGetWallClockTimeBase
+ PyMac_PRECHECK(QTGetWallClockTimeBase);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = QTGetWallClockTimeBase(&wallClockTimeBase);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ TimeBaseObj_New, wallClockTimeBase);
+ return _res;
+}
+
+static PyObject *Qt_QTIdleManagerOpen(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ IdleManager _rv;
+#ifndef QTIdleManagerOpen
+ PyMac_PRECHECK(QTIdleManagerOpen);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = QTIdleManagerOpen();
+ _res = Py_BuildValue("O&",
+ IdleManagerObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qt_CreateMovieControl(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ WindowPtr theWindow;
+ Rect localRect;
+ Movie theMovie;
+ UInt32 options;
+ ControlHandle returnedControl;
+#ifndef CreateMovieControl
+ PyMac_PRECHECK(CreateMovieControl);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ WinObj_Convert, &theWindow,
+ MovieObj_Convert, &theMovie,
+ &options))
+ return NULL;
+ _err = CreateMovieControl(theWindow,
+ &localRect,
+ theMovie,
+ options,
+ &returnedControl);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&",
+ PyMac_BuildRect, &localRect,
+ CtlObj_New, returnedControl);
+ return _res;
+}
+
static PyObject *Qt_DisposeMatte(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -6995,6 +7463,26 @@ static PyObject *Qt_NewMovie(PyObject *_self, PyObject *_args)
return _res;
}
+static PyObject *Qt_QTGetTimeUntilNextTask(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long duration;
+ long scale;
+#ifndef QTGetTimeUntilNextTask
+ PyMac_PRECHECK(QTGetTimeUntilNextTask);
+#endif
+ if (!PyArg_ParseTuple(_args, "l",
+ &scale))
+ return NULL;
+ _err = QTGetTimeUntilNextTask(&duration,
+ scale);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ duration);
+ return _res;
+}
+
static PyObject *Qt_GetDataHandler(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -7374,20 +7862,20 @@ static PyObject *Qt_NewMovieFromDataRef(PyObject *_self, PyObject *_args)
short flags;
short id;
Handle dataRef;
- OSType dataRefType;
+ OSType dtaRefType;
#ifndef NewMovieFromDataRef
PyMac_PRECHECK(NewMovieFromDataRef);
#endif
if (!PyArg_ParseTuple(_args, "hO&O&",
&flags,
ResObj_Convert, &dataRef,
- PyMac_GetOSType, &dataRefType))
+ PyMac_GetOSType, &dtaRefType))
return NULL;
_err = NewMovieFromDataRef(&m,
flags,
&id,
dataRef,
- dataRefType);
+ dtaRefType);
if (_err != noErr) return PyMac_Error(_err);
_res = Py_BuildValue("O&h",
MovieObj_New, m,
@@ -7395,6 +7883,67 @@ static PyObject *Qt_NewMovieFromDataRef(PyObject *_self, PyObject *_args)
return _res;
}
+static PyObject *Qt_NewMovieFromStorageOffset(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Movie theMovie;
+ DataHandler dh;
+ wide fileOffset;
+ short newMovieFlags;
+ Boolean dataRefWasCataRefType;
+#ifndef NewMovieFromStorageOffset
+ PyMac_PRECHECK(NewMovieFromStorageOffset);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&h",
+ CmpInstObj_Convert, &dh,
+ PyMac_Getwide, &fileOffset,
+ &newMovieFlags))
+ return NULL;
+ _err = NewMovieFromStorageOffset(&theMovie,
+ dh,
+ &fileOffset,
+ newMovieFlags,
+ &dataRefWasCataRefType);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&b",
+ MovieObj_New, theMovie,
+ dataRefWasCataRefType);
+ return _res;
+}
+
+static PyObject *Qt_NewMovieForDataRefFromHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Movie theMovie;
+ Handle h;
+ short newMovieFlags;
+ Boolean dataRefWasChanged;
+ Handle dataRef;
+ OSType dataRefType;
+#ifndef NewMovieForDataRefFromHandle
+ PyMac_PRECHECK(NewMovieForDataRefFromHandle);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&hO&O&",
+ ResObj_Convert, &h,
+ &newMovieFlags,
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
+ return NULL;
+ _err = NewMovieForDataRefFromHandle(&theMovie,
+ h,
+ newMovieFlags,
+ &dataRefWasChanged,
+ dataRef,
+ dataRefType);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&b",
+ MovieObj_New, theMovie,
+ dataRefWasChanged);
+ return _res;
+}
+
static PyObject *Qt_RemoveMovieResource(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -7416,6 +7965,106 @@ static PyObject *Qt_RemoveMovieResource(PyObject *_self, PyObject *_args)
return _res;
}
+static PyObject *Qt_CreateMovieStorage(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataRef;
+ OSType dataRefType;
+ OSType creator;
+ ScriptCode scriptTag;
+ long createMovieFileFlags;
+ DataHandler outDataHandler;
+ Movie newmovie;
+#ifndef CreateMovieStorage
+ PyMac_PRECHECK(CreateMovieStorage);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&O&hl",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType,
+ PyMac_GetOSType, &creator,
+ &scriptTag,
+ &createMovieFileFlags))
+ return NULL;
+ _err = CreateMovieStorage(dataRef,
+ dataRefType,
+ creator,
+ scriptTag,
+ createMovieFileFlags,
+ &outDataHandler,
+ &newmovie);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&",
+ CmpInstObj_New, outDataHandler,
+ MovieObj_New, newmovie);
+ return _res;
+}
+
+static PyObject *Qt_OpenMovieStorage(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataRef;
+ OSType dataRefType;
+ long flags;
+ DataHandler outDataHandler;
+#ifndef OpenMovieStorage
+ PyMac_PRECHECK(OpenMovieStorage);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType,
+ &flags))
+ return NULL;
+ _err = OpenMovieStorage(dataRef,
+ dataRefType,
+ flags,
+ &outDataHandler);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CmpInstObj_New, outDataHandler);
+ return _res;
+}
+
+static PyObject *Qt_CloseMovieStorage(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ DataHandler dh;
+#ifndef CloseMovieStorage
+ PyMac_PRECHECK(CloseMovieStorage);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &dh))
+ return NULL;
+ _err = CloseMovieStorage(dh);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_DeleteMovieStorage(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataRef;
+ OSType dataRefType;
+#ifndef DeleteMovieStorage
+ PyMac_PRECHECK(DeleteMovieStorage);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
+ return NULL;
+ _err = DeleteMovieStorage(dataRef,
+ dataRefType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *Qt_CreateShortcutMovieFile(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -7755,6 +8404,26 @@ static PyObject *Qt_QTUnregisterAccessKey(PyObject *_self, PyObject *_args)
return _res;
}
+static PyObject *Qt_QTGetSupportedRestrictions(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType inRestrictionClass;
+ UInt32 outRestrictionIDs;
+#ifndef QTGetSupportedRestrictions
+ PyMac_PRECHECK(QTGetSupportedRestrictions);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &inRestrictionClass))
+ return NULL;
+ _err = QTGetSupportedRestrictions(inRestrictionClass,
+ &outRestrictionIDs);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outRestrictionIDs);
+ return _res;
+}
+
static PyObject *Qt_QTTextToNativeText(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -8757,6 +9426,98 @@ static PyObject *Qt_SpriteMediaGetActionVariableAsString(PyObject *_self, PyObje
return _res;
}
+static PyObject *Qt_SpriteMediaNewImage(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ Handle dataRef;
+ OSType dataRefType;
+ QTAtomID desiredID;
+#ifndef SpriteMediaNewImage
+ PyMac_PRECHECK(SpriteMediaNewImage);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&O&l",
+ CmpInstObj_Convert, &mh,
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType,
+ &desiredID))
+ return NULL;
+ _rv = SpriteMediaNewImage(mh,
+ dataRef,
+ dataRefType,
+ desiredID);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaDisposeImage(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short imageIndex;
+#ifndef SpriteMediaDisposeImage
+ PyMac_PRECHECK(SpriteMediaDisposeImage);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&h",
+ CmpInstObj_Convert, &mh,
+ &imageIndex))
+ return NULL;
+ _rv = SpriteMediaDisposeImage(mh,
+ imageIndex);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaImageIndexToID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short imageIndex;
+ QTAtomID imageID;
+#ifndef SpriteMediaImageIndexToID
+ PyMac_PRECHECK(SpriteMediaImageIndexToID);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&h",
+ CmpInstObj_Convert, &mh,
+ &imageIndex))
+ return NULL;
+ _rv = SpriteMediaImageIndexToID(mh,
+ imageIndex,
+ &imageID);
+ _res = Py_BuildValue("ll",
+ _rv,
+ imageID);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaImageIDToIndex(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID imageID;
+ short imageIndex;
+#ifndef SpriteMediaImageIDToIndex
+ PyMac_PRECHECK(SpriteMediaImageIDToIndex);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &imageID))
+ return NULL;
+ _rv = SpriteMediaImageIDToIndex(mh,
+ imageID,
+ &imageIndex);
+ _res = Py_BuildValue("lh",
+ _rv,
+ imageIndex);
+ return _res;
+}
+
static PyObject *Qt_FlashMediaSetPan(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -9494,10 +10255,18 @@ static PyMethodDef Qt_methods[] = {
PyDoc_STR("() -> None")},
{"GetMoviesStickyError", (PyCFunction)Qt_GetMoviesStickyError, 1,
PyDoc_STR("() -> None")},
+ {"QTGetWallClockTimeBase", (PyCFunction)Qt_QTGetWallClockTimeBase, 1,
+ PyDoc_STR("() -> (TimeBase wallClockTimeBase)")},
+ {"QTIdleManagerOpen", (PyCFunction)Qt_QTIdleManagerOpen, 1,
+ PyDoc_STR("() -> (IdleManager _rv)")},
+ {"CreateMovieControl", (PyCFunction)Qt_CreateMovieControl, 1,
+ PyDoc_STR("(WindowPtr theWindow, Movie theMovie, UInt32 options) -> (Rect localRect, ControlHandle returnedControl)")},
{"DisposeMatte", (PyCFunction)Qt_DisposeMatte, 1,
PyDoc_STR("(PixMapHandle theMatte) -> None")},
{"NewMovie", (PyCFunction)Qt_NewMovie, 1,
PyDoc_STR("(long flags) -> (Movie _rv)")},
+ {"QTGetTimeUntilNextTask", (PyCFunction)Qt_QTGetTimeUntilNextTask, 1,
+ PyDoc_STR("(long scale) -> (long duration)")},
{"GetDataHandler", (PyCFunction)Qt_GetDataHandler, 1,
PyDoc_STR("(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)")},
{"PasteHandleIntoMovie", (PyCFunction)Qt_PasteHandleIntoMovie, 1,
@@ -9529,9 +10298,21 @@ static PyMethodDef Qt_methods[] = {
{"NewMovieFromDataFork64", (PyCFunction)Qt_NewMovieFromDataFork64, 1,
PyDoc_STR("(long fRefNum, wide fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")},
{"NewMovieFromDataRef", (PyCFunction)Qt_NewMovieFromDataRef, 1,
- PyDoc_STR("(short flags, Handle dataRef, OSType dataRefType) -> (Movie m, short id)")},
+ PyDoc_STR("(short flags, Handle dataRef, OSType dtaRefType) -> (Movie m, short id)")},
+ {"NewMovieFromStorageOffset", (PyCFunction)Qt_NewMovieFromStorageOffset, 1,
+ PyDoc_STR("(DataHandler dh, wide fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasCataRefType)")},
+ {"NewMovieForDataRefFromHandle", (PyCFunction)Qt_NewMovieForDataRefFromHandle, 1,
+ PyDoc_STR("(Handle h, short newMovieFlags, Handle dataRef, OSType dataRefType) -> (Movie theMovie, Boolean dataRefWasChanged)")},
{"RemoveMovieResource", (PyCFunction)Qt_RemoveMovieResource, 1,
PyDoc_STR("(short resRefNum, short resId) -> None")},
+ {"CreateMovieStorage", (PyCFunction)Qt_CreateMovieStorage, 1,
+ PyDoc_STR("(Handle dataRef, OSType dataRefType, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (DataHandler outDataHandler, Movie newmovie)")},
+ {"OpenMovieStorage", (PyCFunction)Qt_OpenMovieStorage, 1,
+ PyDoc_STR("(Handle dataRef, OSType dataRefType, long flags) -> (DataHandler outDataHandler)")},
+ {"CloseMovieStorage", (PyCFunction)Qt_CloseMovieStorage, 1,
+ PyDoc_STR("(DataHandler dh) -> None")},
+ {"DeleteMovieStorage", (PyCFunction)Qt_DeleteMovieStorage, 1,
+ PyDoc_STR("(Handle dataRef, OSType dataRefType) -> None")},
{"CreateShortcutMovieFile", (PyCFunction)Qt_CreateShortcutMovieFile, 1,
PyDoc_STR("(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Handle targetDataRef, OSType targetDataRefType) -> None")},
{"CanQuickTimeOpenFile", (PyCFunction)Qt_CanQuickTimeOpenFile, 1,
@@ -9560,6 +10341,8 @@ static PyMethodDef Qt_methods[] = {
PyDoc_STR("(Str255 accessKeyType, long flags, Handle accessKey) -> None")},
{"QTUnregisterAccessKey", (PyCFunction)Qt_QTUnregisterAccessKey, 1,
PyDoc_STR("(Str255 accessKeyType, long flags, Handle accessKey) -> None")},
+ {"QTGetSupportedRestrictions", (PyCFunction)Qt_QTGetSupportedRestrictions, 1,
+ PyDoc_STR("(OSType inRestrictionClass) -> (UInt32 outRestrictionIDs)")},
{"QTTextToNativeText", (PyCFunction)Qt_QTTextToNativeText, 1,
PyDoc_STR("(Handle theText, long encoding, long flags) -> None")},
{"VideoMediaResetStatistics", (PyCFunction)Qt_VideoMediaResetStatistics, 1,
@@ -9634,6 +10417,14 @@ static PyMethodDef Qt_methods[] = {
PyDoc_STR("(MediaHandler mh, QTAtomID variableID, Ptr theCString) -> (ComponentResult _rv)")},
{"SpriteMediaGetActionVariableAsString", (PyCFunction)Qt_SpriteMediaGetActionVariableAsString, 1,
PyDoc_STR("(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, Handle theCString)")},
+ {"SpriteMediaNewImage", (PyCFunction)Qt_SpriteMediaNewImage, 1,
+ PyDoc_STR("(MediaHandler mh, Handle dataRef, OSType dataRefType, QTAtomID desiredID) -> (ComponentResult _rv)")},
+ {"SpriteMediaDisposeImage", (PyCFunction)Qt_SpriteMediaDisposeImage, 1,
+ PyDoc_STR("(MediaHandler mh, short imageIndex) -> (ComponentResult _rv)")},
+ {"SpriteMediaImageIndexToID", (PyCFunction)Qt_SpriteMediaImageIndexToID, 1,
+ PyDoc_STR("(MediaHandler mh, short imageIndex) -> (ComponentResult _rv, QTAtomID imageID)")},
+ {"SpriteMediaImageIDToIndex", (PyCFunction)Qt_SpriteMediaImageIDToIndex, 1,
+ PyDoc_STR("(MediaHandler mh, QTAtomID imageID) -> (ComponentResult _rv, short imageIndex)")},
{"FlashMediaSetPan", (PyCFunction)Qt_FlashMediaSetPan, 1,
PyDoc_STR("(MediaHandler mh, short xPercent, short yPercent) -> (ComponentResult _rv)")},
{"FlashMediaSetZoom", (PyCFunction)Qt_FlashMediaSetZoom, 1,
@@ -9731,6 +10522,13 @@ void init_Qt(void)
if (Qt_Error == NULL ||
PyDict_SetItemString(d, "Error", Qt_Error) != 0)
return;
+ IdleManager_Type.ob_type = &PyType_Type;
+ if (PyType_Ready(&IdleManager_Type) < 0) return;
+ Py_INCREF(&IdleManager_Type);
+ PyModule_AddObject(m, "IdleManager", (PyObject *)&IdleManager_Type);
+ /* Backward-compatible name */
+ Py_INCREF(&IdleManager_Type);
+ PyModule_AddObject(m, "IdleManagerType", (PyObject *)&IdleManager_Type);
MovieController_Type.ob_type = &PyType_Type;
if (PyType_Ready(&MovieController_Type) < 0) return;
Py_INCREF(&MovieController_Type);
diff --git a/Mac/Modules/qt/qtscan.py b/Mac/Modules/qt/qtscan.py
index 86ddd54..eca1f23 100644
--- a/Mac/Modules/qt/qtscan.py
+++ b/Mac/Modules/qt/qtscan.py
@@ -8,7 +8,7 @@ from scantools import Scanner
LONG = "QuickTime"
SHORT = "qt"
-OBJECTS = ("Movie", "Track", "Media", "UserData", "TimeBase", "MovieController")
+OBJECTS = ("Movie", "Track", "Media", "UserData", "TimeBase", "MovieController", "IdleManager")
def main():
input = "Movies.h"
@@ -91,6 +91,10 @@ class MyScanner(Scanner):
"MatrixRecord_ptr",
"SampleReferencePtr",
"QTTweener",
+ "QTErrorReplacementPtr",
+ "QTRestrictionSet",
+ "QTUUID",
+ "QTUUID_ptr",
# Routine pointers, not yet.
"MoviesErrorUPP",
@@ -109,6 +113,7 @@ class MyScanner(Scanner):
"MovieExecuteWiredActionsUPP",
"QTBandwidthNotificationUPP",
"DoMCActionUPP",
+ "QTNextTaskNeededSoonerCallbackUPP",
"SampleReference64Ptr", # Don't know what this does, yet
"QTRuntimeSpriteDescPtr",
diff --git a/Mac/Modules/qt/qtsupport.py b/Mac/Modules/qt/qtsupport.py
index 589b837..4eb906e 100644
--- a/Mac/Modules/qt/qtsupport.py
+++ b/Mac/Modules/qt/qtsupport.py
@@ -115,6 +115,7 @@ Media = OpaqueByValueType('Media', 'MediaObj')
UserData = OpaqueByValueType('UserData', 'UserDataObj')
TimeBase = OpaqueByValueType('TimeBase', 'TimeBaseObj')
MovieController = OpaqueByValueType('MovieController', 'MovieCtlObj')
+IdleManager = OpaqueByValueType('IdleManager', 'IdleManagerObj')
# Other opaque objects
Component = OpaqueByValueType('Component', 'CmpObj')
@@ -230,6 +231,13 @@ class MovieCtlObjectDefinition(PEP253Mixin, GlobalObjectDefinition):
def outputFreeIt(self, itselfname):
Output("DisposeMovieController(%s);", itselfname)
+class IdleManagerObjectDefinition(PEP253Mixin, GlobalObjectDefinition):
+ def outputCheckNewArg(self):
+ Output("""if (itself == NULL) {
+ PyErr_SetString(Qt_Error,"Cannot create null IdleManager");
+ return NULL;
+ }""")
+
# From here on it's basically all boiler plate...
# Create the generator groups and link them
@@ -240,7 +248,9 @@ Media_object = MediaObjectDefinition('Media', 'MediaObj', 'Media')
UserData_object = UserDataObjectDefinition('UserData', 'UserDataObj', 'UserData')
TimeBase_object = TimeBaseObjectDefinition('TimeBase', 'TimeBaseObj', 'TimeBase')
MovieController_object = MovieCtlObjectDefinition('MovieController', 'MovieCtlObj', 'MovieController')
+IdleManager_object = IdleManagerObjectDefinition('IdleManager', 'IdleManagerObj', 'IdleManager')
+module.addobject(IdleManager_object)
module.addobject(MovieController_object)
module.addobject(TimeBase_object)
module.addobject(UserData_object)
@@ -254,6 +264,7 @@ Method = OSErrWeakLinkMethodGenerator
# Create and populate the lists
functions = []
+IdleManager_methods = []
MovieController_methods = []
TimeBase_methods = []
UserData_methods = []
generated by cgit v0.12 at 2024-11-27 02:01:52 (GMT)