diff options
Diffstat (limited to 'Mac/Modules')
| -rw-r--r-- | Mac/Modules/qt/_Qtmodule.c | 4266 | ||||
| -rw-r--r-- | Mac/Modules/qt/qtscan.py | 36 | ||||
| -rw-r--r-- | Mac/Modules/qt/qtsupport.py | 8 |
3 files changed, 4309 insertions, 1 deletions
diff --git a/Mac/Modules/qt/_Qtmodule.c b/Mac/Modules/qt/_Qtmodule.c index 69ada2e..7d0bd1e 100644 --- a/Mac/Modules/qt/_Qtmodule.c +++ b/Mac/Modules/qt/_Qtmodule.c @@ -10182,6 +10182,3912 @@ static PyObject *Qt_MusicMediaGetIndexedTunePlayer(PyObject *_self, PyObject *_a return _res; } +static PyObject *Qt_CodecManagerVersion(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + long version; +#ifndef CodecManagerVersion + PyMac_PRECHECK(CodecManagerVersion); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = CodecManagerVersion(&version); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + version); + return _res; +} + +static PyObject *Qt_GetMaxCompressionSize(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + PixMapHandle src; + Rect srcRect; + short colorDepth; + CodecQ quality; + CodecType cType; + CompressorComponent codec; + long size; +#ifndef GetMaxCompressionSize + PyMac_PRECHECK(GetMaxCompressionSize); +#endif + if (!PyArg_ParseTuple(_args, "O&O&hlO&O&", + ResObj_Convert, &src, + PyMac_GetRect, &srcRect, + &colorDepth, + &quality, + PyMac_GetOSType, &cType, + CmpObj_Convert, &codec)) + return NULL; + _err = GetMaxCompressionSize(src, + &srcRect, + colorDepth, + quality, + cType, + codec, + &size); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + size); + return _res; +} + +static PyObject *Qt_GetCompressionTime(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + PixMapHandle src; + Rect srcRect; + short colorDepth; + CodecType cType; + CompressorComponent codec; + CodecQ spatialQuality; + CodecQ temporalQuality; + unsigned long compressTime; +#ifndef GetCompressionTime + PyMac_PRECHECK(GetCompressionTime); +#endif + if (!PyArg_ParseTuple(_args, "O&O&hO&O&", + ResObj_Convert, &src, + PyMac_GetRect, &srcRect, + &colorDepth, + PyMac_GetOSType, &cType, + CmpObj_Convert, &codec)) + return NULL; + _err = GetCompressionTime(src, + &srcRect, + colorDepth, + cType, + codec, + &spatialQuality, + &temporalQuality, + &compressTime); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("lll", + spatialQuality, + temporalQuality, + compressTime); + return _res; +} + +static PyObject *Qt_CompressImage(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + PixMapHandle src; + Rect srcRect; + CodecQ quality; + CodecType cType; + ImageDescriptionHandle desc; + Ptr data; +#ifndef CompressImage + PyMac_PRECHECK(CompressImage); +#endif + if (!PyArg_ParseTuple(_args, "O&O&lO&O&s", + ResObj_Convert, &src, + PyMac_GetRect, &srcRect, + &quality, + PyMac_GetOSType, &cType, + ResObj_Convert, &desc, + &data)) + return NULL; + _err = CompressImage(src, + &srcRect, + quality, + cType, + desc, + data); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_DecompressImage(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Ptr data; + ImageDescriptionHandle desc; + PixMapHandle dst; + Rect srcRect; + Rect dstRect; + short mode; + RgnHandle mask; +#ifndef DecompressImage + PyMac_PRECHECK(DecompressImage); +#endif + if (!PyArg_ParseTuple(_args, "sO&O&O&O&hO&", + &data, + ResObj_Convert, &desc, + ResObj_Convert, &dst, + PyMac_GetRect, &srcRect, + PyMac_GetRect, &dstRect, + &mode, + ResObj_Convert, &mask)) + return NULL; + _err = DecompressImage(data, + desc, + dst, + &srcRect, + &dstRect, + mode, + mask); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_GetSimilarity(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + PixMapHandle src; + Rect srcRect; + ImageDescriptionHandle desc; + Ptr data; + Fixed similarity; +#ifndef GetSimilarity + PyMac_PRECHECK(GetSimilarity); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&s", + ResObj_Convert, &src, + PyMac_GetRect, &srcRect, + ResObj_Convert, &desc, + &data)) + return NULL; + _err = GetSimilarity(src, + &srcRect, + desc, + data, + &similarity); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildFixed, similarity); + return _res; +} + +static PyObject *Qt_GetImageDescriptionCTable(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + ImageDescriptionHandle desc; + CTabHandle ctable; +#ifndef GetImageDescriptionCTable + PyMac_PRECHECK(GetImageDescriptionCTable); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &desc)) + return NULL; + _err = GetImageDescriptionCTable(desc, + &ctable); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, ctable); + return _res; +} + +static PyObject *Qt_SetImageDescriptionCTable(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + ImageDescriptionHandle desc; + CTabHandle ctable; +#ifndef SetImageDescriptionCTable + PyMac_PRECHECK(SetImageDescriptionCTable); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + ResObj_Convert, &desc, + ResObj_Convert, &ctable)) + return NULL; + _err = SetImageDescriptionCTable(desc, + ctable); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_GetImageDescriptionExtension(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + ImageDescriptionHandle desc; + Handle extension; + long idType; + long index; +#ifndef GetImageDescriptionExtension + PyMac_PRECHECK(GetImageDescriptionExtension); +#endif + if (!PyArg_ParseTuple(_args, "O&ll", + ResObj_Convert, &desc, + &idType, + &index)) + return NULL; + _err = GetImageDescriptionExtension(desc, + &extension, + idType, + index); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, extension); + return _res; +} + +static PyObject *Qt_AddImageDescriptionExtension(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + ImageDescriptionHandle desc; + Handle extension; + long idType; +#ifndef AddImageDescriptionExtension + PyMac_PRECHECK(AddImageDescriptionExtension); +#endif + if (!PyArg_ParseTuple(_args, "O&O&l", + ResObj_Convert, &desc, + ResObj_Convert, &extension, + &idType)) + return NULL; + _err = AddImageDescriptionExtension(desc, + extension, + idType); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_RemoveImageDescriptionExtension(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + ImageDescriptionHandle desc; + long idType; + long index; +#ifndef RemoveImageDescriptionExtension + PyMac_PRECHECK(RemoveImageDescriptionExtension); +#endif + if (!PyArg_ParseTuple(_args, "O&ll", + ResObj_Convert, &desc, + &idType, + &index)) + return NULL; + _err = RemoveImageDescriptionExtension(desc, + idType, + index); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_CountImageDescriptionExtensionType(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + ImageDescriptionHandle desc; + long idType; + long count; +#ifndef CountImageDescriptionExtensionType + PyMac_PRECHECK(CountImageDescriptionExtensionType); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + ResObj_Convert, &desc, + &idType)) + return NULL; + _err = CountImageDescriptionExtensionType(desc, + idType, + &count); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + count); + return _res; +} + +static PyObject *Qt_GetNextImageDescriptionExtensionType(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + ImageDescriptionHandle desc; + long idType; +#ifndef GetNextImageDescriptionExtensionType + PyMac_PRECHECK(GetNextImageDescriptionExtensionType); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &desc)) + return NULL; + _err = GetNextImageDescriptionExtensionType(desc, + &idType); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + idType); + return _res; +} + +static PyObject *Qt_FindCodec(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + CodecType cType; + CodecComponent specCodec; + CompressorComponent compressor; + DecompressorComponent decompressor; +#ifndef FindCodec + PyMac_PRECHECK(FindCodec); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetOSType, &cType, + CmpObj_Convert, &specCodec)) + return NULL; + _err = FindCodec(cType, + specCodec, + &compressor, + &decompressor); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&O&", + CmpObj_New, compressor, + CmpObj_New, decompressor); + return _res; +} + +static PyObject *Qt_CompressPicture(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + PicHandle srcPicture; + PicHandle dstPicture; + CodecQ quality; + CodecType cType; +#ifndef CompressPicture + PyMac_PRECHECK(CompressPicture); +#endif + if (!PyArg_ParseTuple(_args, "O&O&lO&", + ResObj_Convert, &srcPicture, + ResObj_Convert, &dstPicture, + &quality, + PyMac_GetOSType, &cType)) + return NULL; + _err = CompressPicture(srcPicture, + dstPicture, + quality, + cType); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_CompressPictureFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short srcRefNum; + short dstRefNum; + CodecQ quality; + CodecType cType; +#ifndef CompressPictureFile + PyMac_PRECHECK(CompressPictureFile); +#endif + if (!PyArg_ParseTuple(_args, "hhlO&", + &srcRefNum, + &dstRefNum, + &quality, + PyMac_GetOSType, &cType)) + return NULL; + _err = CompressPictureFile(srcRefNum, + dstRefNum, + quality, + cType); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_ConvertImage(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + ImageDescriptionHandle srcDD; + Ptr srcData; + short colorDepth; + CTabHandle ctable; + CodecQ accuracy; + CodecQ quality; + CodecType cType; + CodecComponent codec; + ImageDescriptionHandle dstDD; + Ptr dstData; +#ifndef ConvertImage + PyMac_PRECHECK(ConvertImage); +#endif + if (!PyArg_ParseTuple(_args, "O&shO&llO&O&O&s", + ResObj_Convert, &srcDD, + &srcData, + &colorDepth, + ResObj_Convert, &ctable, + &accuracy, + &quality, + PyMac_GetOSType, &cType, + CmpObj_Convert, &codec, + ResObj_Convert, &dstDD, + &dstData)) + return NULL; + _err = ConvertImage(srcDD, + srcData, + colorDepth, + ctable, + accuracy, + quality, + cType, + codec, + dstDD, + dstData); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_AddFilePreview(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short resRefNum; + OSType previewType; + Handle previewData; +#ifndef AddFilePreview + PyMac_PRECHECK(AddFilePreview); +#endif + if (!PyArg_ParseTuple(_args, "hO&O&", + &resRefNum, + PyMac_GetOSType, &previewType, + ResObj_Convert, &previewData)) + return NULL; + _err = AddFilePreview(resRefNum, + previewType, + previewData); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_GetBestDeviceRect(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + GDHandle gdh; + Rect rp; +#ifndef GetBestDeviceRect + PyMac_PRECHECK(GetBestDeviceRect); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = GetBestDeviceRect(&gdh, + &rp); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&O&", + OptResObj_New, gdh, + PyMac_BuildRect, &rp); + return _res; +} + +static PyObject *Qt_GDHasScale(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + GDHandle gdh; + short depth; + Fixed scale; +#ifndef GDHasScale + PyMac_PRECHECK(GDHasScale); +#endif + if (!PyArg_ParseTuple(_args, "O&h", + OptResObj_Convert, &gdh, + &depth)) + return NULL; + _err = GDHasScale(gdh, + depth, + &scale); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildFixed, scale); + return _res; +} + +static PyObject *Qt_GDGetScale(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + GDHandle gdh; + Fixed scale; + short flags; +#ifndef GDGetScale + PyMac_PRECHECK(GDGetScale); +#endif + if (!PyArg_ParseTuple(_args, "O&", + OptResObj_Convert, &gdh)) + return NULL; + _err = GDGetScale(gdh, + &scale, + &flags); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&h", + PyMac_BuildFixed, scale, + flags); + return _res; +} + +static PyObject *Qt_GDSetScale(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + GDHandle gdh; + Fixed scale; + short flags; +#ifndef GDSetScale + PyMac_PRECHECK(GDSetScale); +#endif + if (!PyArg_ParseTuple(_args, "O&O&h", + OptResObj_Convert, &gdh, + PyMac_GetFixed, &scale, + &flags)) + return NULL; + _err = GDSetScale(gdh, + scale, + flags); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_GetGraphicsImporterForFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec theFile; + ComponentInstance gi; +#ifndef GetGraphicsImporterForFile + PyMac_PRECHECK(GetGraphicsImporterForFile); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSSpec, &theFile)) + return NULL; + _err = GetGraphicsImporterForFile(&theFile, + &gi); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + CmpInstObj_New, gi); + return _res; +} + +static PyObject *Qt_GetGraphicsImporterForDataRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Handle dataRef; + OSType dataRefType; + ComponentInstance gi; +#ifndef GetGraphicsImporterForDataRef + PyMac_PRECHECK(GetGraphicsImporterForDataRef); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + ResObj_Convert, &dataRef, + PyMac_GetOSType, &dataRefType)) + return NULL; + _err = GetGraphicsImporterForDataRef(dataRef, + dataRefType, + &gi); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + CmpInstObj_New, gi); + return _res; +} + +static PyObject *Qt_GetGraphicsImporterForFileWithFlags(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec theFile; + ComponentInstance gi; + long flags; +#ifndef GetGraphicsImporterForFileWithFlags + PyMac_PRECHECK(GetGraphicsImporterForFileWithFlags); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + PyMac_GetFSSpec, &theFile, + &flags)) + return NULL; + _err = GetGraphicsImporterForFileWithFlags(&theFile, + &gi, + flags); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + CmpInstObj_New, gi); + return _res; +} + +static PyObject *Qt_GetGraphicsImporterForDataRefWithFlags(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Handle dataRef; + OSType dataRefType; + ComponentInstance gi; + long flags; +#ifndef GetGraphicsImporterForDataRefWithFlags + PyMac_PRECHECK(GetGraphicsImporterForDataRefWithFlags); +#endif + if (!PyArg_ParseTuple(_args, "O&O&l", + ResObj_Convert, &dataRef, + PyMac_GetOSType, &dataRefType, + &flags)) + return NULL; + _err = GetGraphicsImporterForDataRefWithFlags(dataRef, + dataRefType, + &gi, + flags); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + CmpInstObj_New, gi); + return _res; +} + +static PyObject *Qt_MakeImageDescriptionForPixMap(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + PixMapHandle pixmap; + ImageDescriptionHandle idh; +#ifndef MakeImageDescriptionForPixMap + PyMac_PRECHECK(MakeImageDescriptionForPixMap); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &pixmap)) + return NULL; + _err = MakeImageDescriptionForPixMap(pixmap, + &idh); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, idh); + return _res; +} + +static PyObject *Qt_MakeImageDescriptionForEffect(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + OSType effectType; + ImageDescriptionHandle idh; +#ifndef MakeImageDescriptionForEffect + PyMac_PRECHECK(MakeImageDescriptionForEffect); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetOSType, &effectType)) + return NULL; + _err = MakeImageDescriptionForEffect(effectType, + &idh); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, idh); + return _res; +} + +static PyObject *Qt_QTGetPixelSize(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; + OSType PixelFormat; +#ifndef QTGetPixelSize + PyMac_PRECHECK(QTGetPixelSize); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetOSType, &PixelFormat)) + return NULL; + _rv = QTGetPixelSize(PixelFormat); + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *Qt_QTGetPixelFormatDepthForImageDescription(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; + OSType PixelFormat; +#ifndef QTGetPixelFormatDepthForImageDescription + PyMac_PRECHECK(QTGetPixelFormatDepthForImageDescription); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetOSType, &PixelFormat)) + return NULL; + _rv = QTGetPixelFormatDepthForImageDescription(PixelFormat); + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *Qt_QTGetPixMapHandleRowBytes(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + long _rv; + PixMapHandle pm; +#ifndef QTGetPixMapHandleRowBytes + PyMac_PRECHECK(QTGetPixMapHandleRowBytes); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &pm)) + return NULL; + _rv = QTGetPixMapHandleRowBytes(pm); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_QTSetPixMapHandleRowBytes(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + PixMapHandle pm; + long rowBytes; +#ifndef QTSetPixMapHandleRowBytes + PyMac_PRECHECK(QTSetPixMapHandleRowBytes); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + ResObj_Convert, &pm, + &rowBytes)) + return NULL; + _err = QTSetPixMapHandleRowBytes(pm, + rowBytes); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_QTGetPixMapHandleGammaLevel(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Fixed _rv; + PixMapHandle pm; +#ifndef QTGetPixMapHandleGammaLevel + PyMac_PRECHECK(QTGetPixMapHandleGammaLevel); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &pm)) + return NULL; + _rv = QTGetPixMapHandleGammaLevel(pm); + _res = Py_BuildValue("O&", + PyMac_BuildFixed, _rv); + return _res; +} + +static PyObject *Qt_QTSetPixMapHandleGammaLevel(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + PixMapHandle pm; + Fixed gammaLevel; +#ifndef QTSetPixMapHandleGammaLevel + PyMac_PRECHECK(QTSetPixMapHandleGammaLevel); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + ResObj_Convert, &pm, + PyMac_GetFixed, &gammaLevel)) + return NULL; + _err = QTSetPixMapHandleGammaLevel(pm, + gammaLevel); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_QTGetPixMapHandleRequestedGammaLevel(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Fixed _rv; + PixMapHandle pm; +#ifndef QTGetPixMapHandleRequestedGammaLevel + PyMac_PRECHECK(QTGetPixMapHandleRequestedGammaLevel); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &pm)) + return NULL; + _rv = QTGetPixMapHandleRequestedGammaLevel(pm); + _res = Py_BuildValue("O&", + PyMac_BuildFixed, _rv); + return _res; +} + +static PyObject *Qt_QTSetPixMapHandleRequestedGammaLevel(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + PixMapHandle pm; + Fixed requestedGammaLevel; +#ifndef QTSetPixMapHandleRequestedGammaLevel + PyMac_PRECHECK(QTSetPixMapHandleRequestedGammaLevel); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + ResObj_Convert, &pm, + PyMac_GetFixed, &requestedGammaLevel)) + return NULL; + _err = QTSetPixMapHandleRequestedGammaLevel(pm, + requestedGammaLevel); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Qt_CompAdd(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + wide src; + wide dst; +#ifndef CompAdd + PyMac_PRECHECK(CompAdd); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + CompAdd(&src, + &dst); + _res = Py_BuildValue("O&O&", + PyMac_Buildwide, src, + PyMac_Buildwide, dst); + return _res; +} + +static PyObject *Qt_CompSub(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + wide src; + wide dst; +#ifndef CompSub + PyMac_PRECHECK(CompSub); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + CompSub(&src, + &dst); + _res = Py_BuildValue("O&O&", + PyMac_Buildwide, src, + PyMac_Buildwide, dst); + return _res; +} + +static PyObject *Qt_CompNeg(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + wide dst; +#ifndef CompNeg + PyMac_PRECHECK(CompNeg); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + CompNeg(&dst); + _res = Py_BuildValue("O&", + PyMac_Buildwide, dst); + return _res; +} + +static PyObject *Qt_CompShift(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + wide src; + short shift; +#ifndef CompShift + PyMac_PRECHECK(CompShift); +#endif + if (!PyArg_ParseTuple(_args, "h", + &shift)) + return NULL; + CompShift(&src, + shift); + _res = Py_BuildValue("O&", + PyMac_Buildwide, src); + return _res; +} + +static PyObject *Qt_CompMul(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + long src1; + long src2; + wide dst; +#ifndef CompMul + PyMac_PRECHECK(CompMul); +#endif + if (!PyArg_ParseTuple(_args, "ll", + &src1, + &src2)) + return NULL; + CompMul(src1, + src2, + &dst); + _res = Py_BuildValue("O&", + PyMac_Buildwide, dst); + return _res; +} + +static PyObject *Qt_CompDiv(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + long _rv; + wide numerator; + long denominator; + long remainder; +#ifndef CompDiv + PyMac_PRECHECK(CompDiv); +#endif + if (!PyArg_ParseTuple(_args, "l", + &denominator)) + return NULL; + _rv = CompDiv(&numerator, + denominator, + &remainder); + _res = Py_BuildValue("lO&l", + _rv, + PyMac_Buildwide, numerator, + remainder); + return _res; +} + +static PyObject *Qt_CompFixMul(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + wide compSrc; + Fixed fixSrc; + wide compDst; +#ifndef CompFixMul + PyMac_PRECHECK(CompFixMul); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFixed, &fixSrc)) + return NULL; + CompFixMul(&compSrc, + fixSrc, + &compDst); + _res = Py_BuildValue("O&O&", + PyMac_Buildwide, compSrc, + PyMac_Buildwide, compDst); + return _res; +} + +static PyObject *Qt_CompMulDiv(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + wide co; + long mul; + long divisor; +#ifndef CompMulDiv + PyMac_PRECHECK(CompMulDiv); +#endif + if (!PyArg_ParseTuple(_args, "ll", + &mul, + &divisor)) + return NULL; + CompMulDiv(&co, + mul, + divisor); + _res = Py_BuildValue("O&", + PyMac_Buildwide, co); + return _res; +} + +static PyObject *Qt_CompMulDivTrunc(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + wide co; + long mul; + long divisor; + long remainder; +#ifndef CompMulDivTrunc + PyMac_PRECHECK(CompMulDivTrunc); +#endif + if (!PyArg_ParseTuple(_args, "ll", + &mul, + &divisor)) + return NULL; + CompMulDivTrunc(&co, + mul, + divisor, + &remainder); + _res = Py_BuildValue("O&l", + PyMac_Buildwide, co, + remainder); + return _res; +} + +static PyObject *Qt_CompCompare(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + long _rv; + wide a; + wide minusb; +#ifndef CompCompare + PyMac_PRECHECK(CompCompare); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_Getwide, &a, + PyMac_Getwide, &minusb)) + return NULL; + _rv = CompCompare(&a, + &minusb); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_CompSquareRoot(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + unsigned long _rv; + wide src; +#ifndef CompSquareRoot + PyMac_PRECHECK(CompSquareRoot); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_Getwide, &src)) + return NULL; + _rv = CompSquareRoot(&src); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_FixMulDiv(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Fixed _rv; + Fixed src; + Fixed mul; + Fixed divisor; +#ifndef FixMulDiv + PyMac_PRECHECK(FixMulDiv); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + PyMac_GetFixed, &src, + PyMac_GetFixed, &mul, + PyMac_GetFixed, &divisor)) + return NULL; + _rv = FixMulDiv(src, + mul, + divisor); + _res = Py_BuildValue("O&", + PyMac_BuildFixed, _rv); + return _res; +} + +static PyObject *Qt_UnsignedFixMulDiv(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Fixed _rv; + Fixed src; + Fixed mul; + Fixed divisor; +#ifndef UnsignedFixMulDiv + PyMac_PRECHECK(UnsignedFixMulDiv); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + PyMac_GetFixed, &src, + PyMac_GetFixed, &mul, + PyMac_GetFixed, &divisor)) + return NULL; + _rv = UnsignedFixMulDiv(src, + mul, + divisor); + _res = Py_BuildValue("O&", + PyMac_BuildFixed, _rv); + return _res; +} + +static PyObject *Qt_FixExp2(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Fixed _rv; + Fixed src; +#ifndef FixExp2 + PyMac_PRECHECK(FixExp2); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFixed, &src)) + return NULL; + _rv = FixExp2(src); + _res = Py_BuildValue("O&", + PyMac_BuildFixed, _rv); + return _res; +} + +static PyObject *Qt_FixLog2(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Fixed _rv; + Fixed src; +#ifndef FixLog2 + PyMac_PRECHECK(FixLog2); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFixed, &src)) + return NULL; + _rv = FixLog2(src); + _res = Py_BuildValue("O&", + PyMac_BuildFixed, _rv); + return _res; +} + +static PyObject *Qt_FixPow(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Fixed _rv; + Fixed base; + Fixed exp; +#ifndef FixPow + PyMac_PRECHECK(FixPow); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetFixed, &base, + PyMac_GetFixed, &exp)) + return NULL; + _rv = FixPow(base, + exp); + _res = Py_BuildValue("O&", + PyMac_BuildFixed, _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportSetDataReference(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Handle dataRef; + OSType dataReType; +#ifndef GraphicsImportSetDataReference + PyMac_PRECHECK(GraphicsImportSetDataReference); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + CmpObj_Convert, &ci, + ResObj_Convert, &dataRef, + PyMac_GetOSType, &dataReType)) + return NULL; + _rv = GraphicsImportSetDataReference(ci, + dataRef, + dataReType); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetDataReference(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Handle dataRef; + OSType dataReType; +#ifndef GraphicsImportGetDataReference + PyMac_PRECHECK(GraphicsImportGetDataReference); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetDataReference(ci, + &dataRef, + &dataReType); + _res = Py_BuildValue("lO&O&", + _rv, + ResObj_New, dataRef, + PyMac_BuildOSType, dataReType); + return _res; +} + +static PyObject *Qt_GraphicsImportSetDataFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + FSSpec theFile; +#ifndef GraphicsImportSetDataFile + PyMac_PRECHECK(GraphicsImportSetDataFile); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + PyMac_GetFSSpec, &theFile)) + return NULL; + _rv = GraphicsImportSetDataFile(ci, + &theFile); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetDataFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + FSSpec theFile; +#ifndef GraphicsImportGetDataFile + PyMac_PRECHECK(GraphicsImportGetDataFile); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + PyMac_GetFSSpec, &theFile)) + return NULL; + _rv = GraphicsImportGetDataFile(ci, + &theFile); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportSetDataHandle(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Handle h; +#ifndef GraphicsImportSetDataHandle + PyMac_PRECHECK(GraphicsImportSetDataHandle); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + ResObj_Convert, &h)) + return NULL; + _rv = GraphicsImportSetDataHandle(ci, + h); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetDataHandle(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Handle h; +#ifndef GraphicsImportGetDataHandle + PyMac_PRECHECK(GraphicsImportGetDataHandle); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetDataHandle(ci, + &h); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, h); + return _res; +} + +static PyObject *Qt_GraphicsImportGetImageDescription(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + ImageDescriptionHandle desc; +#ifndef GraphicsImportGetImageDescription + PyMac_PRECHECK(GraphicsImportGetImageDescription); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetImageDescription(ci, + &desc); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, desc); + return _res; +} + +static PyObject *Qt_GraphicsImportGetDataOffsetAndSize(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + unsigned long offset; + unsigned long size; +#ifndef GraphicsImportGetDataOffsetAndSize + PyMac_PRECHECK(GraphicsImportGetDataOffsetAndSize); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetDataOffsetAndSize(ci, + &offset, + &size); + _res = Py_BuildValue("lll", + _rv, + offset, + size); + return _res; +} + +static PyObject *Qt_GraphicsImportReadData(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + void * dataPtr; + unsigned long dataOffset; + unsigned long dataSize; +#ifndef GraphicsImportReadData + PyMac_PRECHECK(GraphicsImportReadData); +#endif + if (!PyArg_ParseTuple(_args, "O&sll", + CmpObj_Convert, &ci, + &dataPtr, + &dataOffset, + &dataSize)) + return NULL; + _rv = GraphicsImportReadData(ci, + dataPtr, + dataOffset, + dataSize); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportSetClip(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + RgnHandle clipRgn; +#ifndef GraphicsImportSetClip + PyMac_PRECHECK(GraphicsImportSetClip); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + ResObj_Convert, &clipRgn)) + return NULL; + _rv = GraphicsImportSetClip(ci, + clipRgn); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetClip(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + RgnHandle clipRgn; +#ifndef GraphicsImportGetClip + PyMac_PRECHECK(GraphicsImportGetClip); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetClip(ci, + &clipRgn); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, clipRgn); + return _res; +} + +static PyObject *Qt_GraphicsImportSetSourceRect(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Rect sourceRect; +#ifndef GraphicsImportSetSourceRect + PyMac_PRECHECK(GraphicsImportSetSourceRect); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + PyMac_GetRect, &sourceRect)) + return NULL; + _rv = GraphicsImportSetSourceRect(ci, + &sourceRect); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetSourceRect(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Rect sourceRect; +#ifndef GraphicsImportGetSourceRect + PyMac_PRECHECK(GraphicsImportGetSourceRect); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetSourceRect(ci, + &sourceRect); + _res = Py_BuildValue("lO&", + _rv, + PyMac_BuildRect, &sourceRect); + return _res; +} + +static PyObject *Qt_GraphicsImportGetNaturalBounds(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Rect naturalBounds; +#ifndef GraphicsImportGetNaturalBounds + PyMac_PRECHECK(GraphicsImportGetNaturalBounds); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetNaturalBounds(ci, + &naturalBounds); + _res = Py_BuildValue("lO&", + _rv, + PyMac_BuildRect, &naturalBounds); + return _res; +} + +static PyObject *Qt_GraphicsImportDraw(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; +#ifndef GraphicsImportDraw + PyMac_PRECHECK(GraphicsImportDraw); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportDraw(ci); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportSetGWorld(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + CGrafPtr port; + GDHandle gd; +#ifndef GraphicsImportSetGWorld + PyMac_PRECHECK(GraphicsImportSetGWorld); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + CmpObj_Convert, &ci, + GrafObj_Convert, &port, + OptResObj_Convert, &gd)) + return NULL; + _rv = GraphicsImportSetGWorld(ci, + port, + gd); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetGWorld(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + CGrafPtr port; + GDHandle gd; +#ifndef GraphicsImportGetGWorld + PyMac_PRECHECK(GraphicsImportGetGWorld); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetGWorld(ci, + &port, + &gd); + _res = Py_BuildValue("lO&O&", + _rv, + GrafObj_New, port, + OptResObj_New, gd); + return _res; +} + +static PyObject *Qt_GraphicsImportSetBoundsRect(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Rect bounds; +#ifndef GraphicsImportSetBoundsRect + PyMac_PRECHECK(GraphicsImportSetBoundsRect); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + PyMac_GetRect, &bounds)) + return NULL; + _rv = GraphicsImportSetBoundsRect(ci, + &bounds); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetBoundsRect(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Rect bounds; +#ifndef GraphicsImportGetBoundsRect + PyMac_PRECHECK(GraphicsImportGetBoundsRect); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetBoundsRect(ci, + &bounds); + _res = Py_BuildValue("lO&", + _rv, + PyMac_BuildRect, &bounds); + return _res; +} + +static PyObject *Qt_GraphicsImportSaveAsPicture(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + FSSpec fss; + ScriptCode scriptTag; +#ifndef GraphicsImportSaveAsPicture + PyMac_PRECHECK(GraphicsImportSaveAsPicture); +#endif + if (!PyArg_ParseTuple(_args, "O&O&h", + CmpObj_Convert, &ci, + PyMac_GetFSSpec, &fss, + &scriptTag)) + return NULL; + _rv = GraphicsImportSaveAsPicture(ci, + &fss, + scriptTag); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportSetGraphicsMode(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + long graphicsMode; + RGBColor opColor; +#ifndef GraphicsImportSetGraphicsMode + PyMac_PRECHECK(GraphicsImportSetGraphicsMode); +#endif + if (!PyArg_ParseTuple(_args, "O&lO&", + CmpObj_Convert, &ci, + &graphicsMode, + QdRGB_Convert, &opColor)) + return NULL; + _rv = GraphicsImportSetGraphicsMode(ci, + graphicsMode, + &opColor); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetGraphicsMode(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + long graphicsMode; + RGBColor opColor; +#ifndef GraphicsImportGetGraphicsMode + PyMac_PRECHECK(GraphicsImportGetGraphicsMode); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetGraphicsMode(ci, + &graphicsMode, + &opColor); + _res = Py_BuildValue("llO&", + _rv, + graphicsMode, + QdRGB_New, &opColor); + return _res; +} + +static PyObject *Qt_GraphicsImportSetQuality(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + CodecQ quality; +#ifndef GraphicsImportSetQuality + PyMac_PRECHECK(GraphicsImportSetQuality); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + CmpObj_Convert, &ci, + &quality)) + return NULL; + _rv = GraphicsImportSetQuality(ci, + quality); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetQuality(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + CodecQ quality; +#ifndef GraphicsImportGetQuality + PyMac_PRECHECK(GraphicsImportGetQuality); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetQuality(ci, + &quality); + _res = Py_BuildValue("ll", + _rv, + quality); + return _res; +} + +static PyObject *Qt_GraphicsImportSaveAsQuickTimeImageFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + FSSpec fss; + ScriptCode scriptTag; +#ifndef GraphicsImportSaveAsQuickTimeImageFile + PyMac_PRECHECK(GraphicsImportSaveAsQuickTimeImageFile); +#endif + if (!PyArg_ParseTuple(_args, "O&O&h", + CmpObj_Convert, &ci, + PyMac_GetFSSpec, &fss, + &scriptTag)) + return NULL; + _rv = GraphicsImportSaveAsQuickTimeImageFile(ci, + &fss, + scriptTag); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportSetDataReferenceOffsetAndLimit(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + unsigned long offset; + unsigned long limit; +#ifndef GraphicsImportSetDataReferenceOffsetAndLimit + PyMac_PRECHECK(GraphicsImportSetDataReferenceOffsetAndLimit); +#endif + if (!PyArg_ParseTuple(_args, "O&ll", + CmpObj_Convert, &ci, + &offset, + &limit)) + return NULL; + _rv = GraphicsImportSetDataReferenceOffsetAndLimit(ci, + offset, + limit); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetDataReferenceOffsetAndLimit(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + unsigned long offset; + unsigned long limit; +#ifndef GraphicsImportGetDataReferenceOffsetAndLimit + PyMac_PRECHECK(GraphicsImportGetDataReferenceOffsetAndLimit); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetDataReferenceOffsetAndLimit(ci, + &offset, + &limit); + _res = Py_BuildValue("lll", + _rv, + offset, + limit); + return _res; +} + +static PyObject *Qt_GraphicsImportGetAliasedDataReference(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Handle dataRef; + OSType dataRefType; +#ifndef GraphicsImportGetAliasedDataReference + PyMac_PRECHECK(GraphicsImportGetAliasedDataReference); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetAliasedDataReference(ci, + &dataRef, + &dataRefType); + _res = Py_BuildValue("lO&O&", + _rv, + ResObj_New, dataRef, + PyMac_BuildOSType, dataRefType); + return _res; +} + +static PyObject *Qt_GraphicsImportValidate(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Boolean valid; +#ifndef GraphicsImportValidate + PyMac_PRECHECK(GraphicsImportValidate); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportValidate(ci, + &valid); + _res = Py_BuildValue("lb", + _rv, + valid); + return _res; +} + +static PyObject *Qt_GraphicsImportGetMetaData(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + void * userData; +#ifndef GraphicsImportGetMetaData + PyMac_PRECHECK(GraphicsImportGetMetaData); +#endif + if (!PyArg_ParseTuple(_args, "O&s", + CmpObj_Convert, &ci, + &userData)) + return NULL; + _rv = GraphicsImportGetMetaData(ci, + userData); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetMIMETypeList(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + void * qtAtomContainerPtr; +#ifndef GraphicsImportGetMIMETypeList + PyMac_PRECHECK(GraphicsImportGetMIMETypeList); +#endif + if (!PyArg_ParseTuple(_args, "O&s", + CmpObj_Convert, &ci, + &qtAtomContainerPtr)) + return NULL; + _rv = GraphicsImportGetMIMETypeList(ci, + qtAtomContainerPtr); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportDoesDrawAllPixels(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + short drawsAllPixels; +#ifndef GraphicsImportDoesDrawAllPixels + PyMac_PRECHECK(GraphicsImportDoesDrawAllPixels); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportDoesDrawAllPixels(ci, + &drawsAllPixels); + _res = Py_BuildValue("lh", + _rv, + drawsAllPixels); + return _res; +} + +static PyObject *Qt_GraphicsImportGetAsPicture(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + PicHandle picture; +#ifndef GraphicsImportGetAsPicture + PyMac_PRECHECK(GraphicsImportGetAsPicture); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetAsPicture(ci, + &picture); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, picture); + return _res; +} + +static PyObject *Qt_GraphicsImportExportImageFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + OSType fileType; + OSType fileCreator; + FSSpec fss; + ScriptCode scriptTag; +#ifndef GraphicsImportExportImageFile + PyMac_PRECHECK(GraphicsImportExportImageFile); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&O&h", + CmpObj_Convert, &ci, + PyMac_GetOSType, &fileType, + PyMac_GetOSType, &fileCreator, + PyMac_GetFSSpec, &fss, + &scriptTag)) + return NULL; + _rv = GraphicsImportExportImageFile(ci, + fileType, + fileCreator, + &fss, + scriptTag); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetExportImageTypeList(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + void * qtAtomContainerPtr; +#ifndef GraphicsImportGetExportImageTypeList + PyMac_PRECHECK(GraphicsImportGetExportImageTypeList); +#endif + if (!PyArg_ParseTuple(_args, "O&s", + CmpObj_Convert, &ci, + &qtAtomContainerPtr)) + return NULL; + _rv = GraphicsImportGetExportImageTypeList(ci, + qtAtomContainerPtr); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetExportSettingsAsAtomContainer(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + void * qtAtomContainerPtr; +#ifndef GraphicsImportGetExportSettingsAsAtomContainer + PyMac_PRECHECK(GraphicsImportGetExportSettingsAsAtomContainer); +#endif + if (!PyArg_ParseTuple(_args, "O&s", + CmpObj_Convert, &ci, + &qtAtomContainerPtr)) + return NULL; + _rv = GraphicsImportGetExportSettingsAsAtomContainer(ci, + qtAtomContainerPtr); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportSetExportSettingsFromAtomContainer(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + void * qtAtomContainer; +#ifndef GraphicsImportSetExportSettingsFromAtomContainer + PyMac_PRECHECK(GraphicsImportSetExportSettingsFromAtomContainer); +#endif + if (!PyArg_ParseTuple(_args, "O&s", + CmpObj_Convert, &ci, + &qtAtomContainer)) + return NULL; + _rv = GraphicsImportSetExportSettingsFromAtomContainer(ci, + qtAtomContainer); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetImageCount(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + unsigned long imageCount; +#ifndef GraphicsImportGetImageCount + PyMac_PRECHECK(GraphicsImportGetImageCount); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetImageCount(ci, + &imageCount); + _res = Py_BuildValue("ll", + _rv, + imageCount); + return _res; +} + +static PyObject *Qt_GraphicsImportSetImageIndex(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + unsigned long imageIndex; +#ifndef GraphicsImportSetImageIndex + PyMac_PRECHECK(GraphicsImportSetImageIndex); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + CmpObj_Convert, &ci, + &imageIndex)) + return NULL; + _rv = GraphicsImportSetImageIndex(ci, + imageIndex); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetImageIndex(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + unsigned long imageIndex; +#ifndef GraphicsImportGetImageIndex + PyMac_PRECHECK(GraphicsImportGetImageIndex); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetImageIndex(ci, + &imageIndex); + _res = Py_BuildValue("ll", + _rv, + imageIndex); + return _res; +} + +static PyObject *Qt_GraphicsImportGetDataOffsetAndSize64(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + wide offset; + wide size; +#ifndef GraphicsImportGetDataOffsetAndSize64 + PyMac_PRECHECK(GraphicsImportGetDataOffsetAndSize64); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetDataOffsetAndSize64(ci, + &offset, + &size); + _res = Py_BuildValue("lO&O&", + _rv, + PyMac_Buildwide, offset, + PyMac_Buildwide, size); + return _res; +} + +static PyObject *Qt_GraphicsImportReadData64(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + void * dataPtr; + wide dataOffset; + unsigned long dataSize; +#ifndef GraphicsImportReadData64 + PyMac_PRECHECK(GraphicsImportReadData64); +#endif + if (!PyArg_ParseTuple(_args, "O&sO&l", + CmpObj_Convert, &ci, + &dataPtr, + PyMac_Getwide, &dataOffset, + &dataSize)) + return NULL; + _rv = GraphicsImportReadData64(ci, + dataPtr, + &dataOffset, + dataSize); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportSetDataReferenceOffsetAndLimit64(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + wide offset; + wide limit; +#ifndef GraphicsImportSetDataReferenceOffsetAndLimit64 + PyMac_PRECHECK(GraphicsImportSetDataReferenceOffsetAndLimit64); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + CmpObj_Convert, &ci, + PyMac_Getwide, &offset, + PyMac_Getwide, &limit)) + return NULL; + _rv = GraphicsImportSetDataReferenceOffsetAndLimit64(ci, + &offset, + &limit); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetDataReferenceOffsetAndLimit64(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + wide offset; + wide limit; +#ifndef GraphicsImportGetDataReferenceOffsetAndLimit64 + PyMac_PRECHECK(GraphicsImportGetDataReferenceOffsetAndLimit64); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetDataReferenceOffsetAndLimit64(ci, + &offset, + &limit); + _res = Py_BuildValue("lO&O&", + _rv, + PyMac_Buildwide, offset, + PyMac_Buildwide, limit); + return _res; +} + +static PyObject *Qt_GraphicsImportGetDefaultClip(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + RgnHandle defaultRgn; +#ifndef GraphicsImportGetDefaultClip + PyMac_PRECHECK(GraphicsImportGetDefaultClip); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetDefaultClip(ci, + &defaultRgn); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, defaultRgn); + return _res; +} + +static PyObject *Qt_GraphicsImportGetDefaultGraphicsMode(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + long defaultGraphicsMode; + RGBColor defaultOpColor; +#ifndef GraphicsImportGetDefaultGraphicsMode + PyMac_PRECHECK(GraphicsImportGetDefaultGraphicsMode); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetDefaultGraphicsMode(ci, + &defaultGraphicsMode, + &defaultOpColor); + _res = Py_BuildValue("llO&", + _rv, + defaultGraphicsMode, + QdRGB_New, &defaultOpColor); + return _res; +} + +static PyObject *Qt_GraphicsImportGetDefaultSourceRect(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Rect defaultSourceRect; +#ifndef GraphicsImportGetDefaultSourceRect + PyMac_PRECHECK(GraphicsImportGetDefaultSourceRect); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetDefaultSourceRect(ci, + &defaultSourceRect); + _res = Py_BuildValue("lO&", + _rv, + PyMac_BuildRect, &defaultSourceRect); + return _res; +} + +static PyObject *Qt_GraphicsImportGetColorSyncProfile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Handle profile; +#ifndef GraphicsImportGetColorSyncProfile + PyMac_PRECHECK(GraphicsImportGetColorSyncProfile); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetColorSyncProfile(ci, + &profile); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, profile); + return _res; +} + +static PyObject *Qt_GraphicsImportSetDestRect(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Rect destRect; +#ifndef GraphicsImportSetDestRect + PyMac_PRECHECK(GraphicsImportSetDestRect); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + PyMac_GetRect, &destRect)) + return NULL; + _rv = GraphicsImportSetDestRect(ci, + &destRect); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetDestRect(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + Rect destRect; +#ifndef GraphicsImportGetDestRect + PyMac_PRECHECK(GraphicsImportGetDestRect); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetDestRect(ci, + &destRect); + _res = Py_BuildValue("lO&", + _rv, + PyMac_BuildRect, &destRect); + return _res; +} + +static PyObject *Qt_GraphicsImportSetFlags(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + long flags; +#ifndef GraphicsImportSetFlags + PyMac_PRECHECK(GraphicsImportSetFlags); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + CmpObj_Convert, &ci, + &flags)) + return NULL; + _rv = GraphicsImportSetFlags(ci, + flags); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsImportGetFlags(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + long flags; +#ifndef GraphicsImportGetFlags + PyMac_PRECHECK(GraphicsImportGetFlags); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetFlags(ci, + &flags); + _res = Py_BuildValue("ll", + _rv, + flags); + return _res; +} + +static PyObject *Qt_GraphicsImportGetBaseDataOffsetAndSize64(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; + wide offset; + wide size; +#ifndef GraphicsImportGetBaseDataOffsetAndSize64 + PyMac_PRECHECK(GraphicsImportGetBaseDataOffsetAndSize64); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportGetBaseDataOffsetAndSize64(ci, + &offset, + &size); + _res = Py_BuildValue("lO&O&", + _rv, + PyMac_Buildwide, offset, + PyMac_Buildwide, size); + return _res; +} + +static PyObject *Qt_GraphicsImportSetImageIndexToThumbnail(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsImportComponent ci; +#ifndef GraphicsImportSetImageIndexToThumbnail + PyMac_PRECHECK(GraphicsImportSetImageIndexToThumbnail); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsImportSetImageIndexToThumbnail(ci); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportDoExport(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + unsigned long actualSizeWritten; +#ifndef GraphicsExportDoExport + PyMac_PRECHECK(GraphicsExportDoExport); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportDoExport(ci, + &actualSizeWritten); + _res = Py_BuildValue("ll", + _rv, + actualSizeWritten); + return _res; +} + +static PyObject *Qt_GraphicsExportCanTranscode(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Boolean canTranscode; +#ifndef GraphicsExportCanTranscode + PyMac_PRECHECK(GraphicsExportCanTranscode); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportCanTranscode(ci, + &canTranscode); + _res = Py_BuildValue("lb", + _rv, + canTranscode); + return _res; +} + +static PyObject *Qt_GraphicsExportDoTranscode(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; +#ifndef GraphicsExportDoTranscode + PyMac_PRECHECK(GraphicsExportDoTranscode); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportDoTranscode(ci); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportCanUseCompressor(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Boolean canUseCompressor; + void * codecSettingsAtomContainerPtr; +#ifndef GraphicsExportCanUseCompressor + PyMac_PRECHECK(GraphicsExportCanUseCompressor); +#endif + if (!PyArg_ParseTuple(_args, "O&s", + CmpObj_Convert, &ci, + &codecSettingsAtomContainerPtr)) + return NULL; + _rv = GraphicsExportCanUseCompressor(ci, + &canUseCompressor, + codecSettingsAtomContainerPtr); + _res = Py_BuildValue("lb", + _rv, + canUseCompressor); + return _res; +} + +static PyObject *Qt_GraphicsExportDoUseCompressor(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + void * codecSettingsAtomContainer; + ImageDescriptionHandle outDesc; +#ifndef GraphicsExportDoUseCompressor + PyMac_PRECHECK(GraphicsExportDoUseCompressor); +#endif + if (!PyArg_ParseTuple(_args, "O&s", + CmpObj_Convert, &ci, + &codecSettingsAtomContainer)) + return NULL; + _rv = GraphicsExportDoUseCompressor(ci, + codecSettingsAtomContainer, + &outDesc); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, outDesc); + return _res; +} + +static PyObject *Qt_GraphicsExportDoStandaloneExport(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; +#ifndef GraphicsExportDoStandaloneExport + PyMac_PRECHECK(GraphicsExportDoStandaloneExport); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportDoStandaloneExport(ci); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetDefaultFileTypeAndCreator(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + OSType fileType; + OSType fileCreator; +#ifndef GraphicsExportGetDefaultFileTypeAndCreator + PyMac_PRECHECK(GraphicsExportGetDefaultFileTypeAndCreator); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetDefaultFileTypeAndCreator(ci, + &fileType, + &fileCreator); + _res = Py_BuildValue("lO&O&", + _rv, + PyMac_BuildOSType, fileType, + PyMac_BuildOSType, fileCreator); + return _res; +} + +static PyObject *Qt_GraphicsExportGetDefaultFileNameExtension(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + OSType fileNameExtension; +#ifndef GraphicsExportGetDefaultFileNameExtension + PyMac_PRECHECK(GraphicsExportGetDefaultFileNameExtension); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetDefaultFileNameExtension(ci, + &fileNameExtension); + _res = Py_BuildValue("lO&", + _rv, + PyMac_BuildOSType, fileNameExtension); + return _res; +} + +static PyObject *Qt_GraphicsExportGetMIMETypeList(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + void * qtAtomContainerPtr; +#ifndef GraphicsExportGetMIMETypeList + PyMac_PRECHECK(GraphicsExportGetMIMETypeList); +#endif + if (!PyArg_ParseTuple(_args, "O&s", + CmpObj_Convert, &ci, + &qtAtomContainerPtr)) + return NULL; + _rv = GraphicsExportGetMIMETypeList(ci, + qtAtomContainerPtr); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportSetSettingsFromAtomContainer(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + void * qtAtomContainer; +#ifndef GraphicsExportSetSettingsFromAtomContainer + PyMac_PRECHECK(GraphicsExportSetSettingsFromAtomContainer); +#endif + if (!PyArg_ParseTuple(_args, "O&s", + CmpObj_Convert, &ci, + &qtAtomContainer)) + return NULL; + _rv = GraphicsExportSetSettingsFromAtomContainer(ci, + qtAtomContainer); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetSettingsAsAtomContainer(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + void * qtAtomContainerPtr; +#ifndef GraphicsExportGetSettingsAsAtomContainer + PyMac_PRECHECK(GraphicsExportGetSettingsAsAtomContainer); +#endif + if (!PyArg_ParseTuple(_args, "O&s", + CmpObj_Convert, &ci, + &qtAtomContainerPtr)) + return NULL; + _rv = GraphicsExportGetSettingsAsAtomContainer(ci, + qtAtomContainerPtr); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetSettingsAsText(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Handle theText; +#ifndef GraphicsExportGetSettingsAsText + PyMac_PRECHECK(GraphicsExportGetSettingsAsText); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetSettingsAsText(ci, + &theText); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, theText); + return _res; +} + +static PyObject *Qt_GraphicsExportSetDontRecompress(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Boolean dontRecompress; +#ifndef GraphicsExportSetDontRecompress + PyMac_PRECHECK(GraphicsExportSetDontRecompress); +#endif + if (!PyArg_ParseTuple(_args, "O&b", + CmpObj_Convert, &ci, + &dontRecompress)) + return NULL; + _rv = GraphicsExportSetDontRecompress(ci, + dontRecompress); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetDontRecompress(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Boolean dontRecompress; +#ifndef GraphicsExportGetDontRecompress + PyMac_PRECHECK(GraphicsExportGetDontRecompress); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetDontRecompress(ci, + &dontRecompress); + _res = Py_BuildValue("lb", + _rv, + dontRecompress); + return _res; +} + +static PyObject *Qt_GraphicsExportSetInterlaceStyle(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + unsigned long interlaceStyle; +#ifndef GraphicsExportSetInterlaceStyle + PyMac_PRECHECK(GraphicsExportSetInterlaceStyle); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + CmpObj_Convert, &ci, + &interlaceStyle)) + return NULL; + _rv = GraphicsExportSetInterlaceStyle(ci, + interlaceStyle); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetInterlaceStyle(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + unsigned long interlaceStyle; +#ifndef GraphicsExportGetInterlaceStyle + PyMac_PRECHECK(GraphicsExportGetInterlaceStyle); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetInterlaceStyle(ci, + &interlaceStyle); + _res = Py_BuildValue("ll", + _rv, + interlaceStyle); + return _res; +} + +static PyObject *Qt_GraphicsExportSetMetaData(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + void * userData; +#ifndef GraphicsExportSetMetaData + PyMac_PRECHECK(GraphicsExportSetMetaData); +#endif + if (!PyArg_ParseTuple(_args, "O&s", + CmpObj_Convert, &ci, + &userData)) + return NULL; + _rv = GraphicsExportSetMetaData(ci, + userData); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetMetaData(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + void * userData; +#ifndef GraphicsExportGetMetaData + PyMac_PRECHECK(GraphicsExportGetMetaData); +#endif + if (!PyArg_ParseTuple(_args, "O&s", + CmpObj_Convert, &ci, + &userData)) + return NULL; + _rv = GraphicsExportGetMetaData(ci, + userData); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportSetTargetDataSize(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + unsigned long targetDataSize; +#ifndef GraphicsExportSetTargetDataSize + PyMac_PRECHECK(GraphicsExportSetTargetDataSize); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + CmpObj_Convert, &ci, + &targetDataSize)) + return NULL; + _rv = GraphicsExportSetTargetDataSize(ci, + targetDataSize); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetTargetDataSize(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + unsigned long targetDataSize; +#ifndef GraphicsExportGetTargetDataSize + PyMac_PRECHECK(GraphicsExportGetTargetDataSize); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetTargetDataSize(ci, + &targetDataSize); + _res = Py_BuildValue("ll", + _rv, + targetDataSize); + return _res; +} + +static PyObject *Qt_GraphicsExportSetCompressionMethod(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + long compressionMethod; +#ifndef GraphicsExportSetCompressionMethod + PyMac_PRECHECK(GraphicsExportSetCompressionMethod); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + CmpObj_Convert, &ci, + &compressionMethod)) + return NULL; + _rv = GraphicsExportSetCompressionMethod(ci, + compressionMethod); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetCompressionMethod(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + long compressionMethod; +#ifndef GraphicsExportGetCompressionMethod + PyMac_PRECHECK(GraphicsExportGetCompressionMethod); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetCompressionMethod(ci, + &compressionMethod); + _res = Py_BuildValue("ll", + _rv, + compressionMethod); + return _res; +} + +static PyObject *Qt_GraphicsExportSetCompressionQuality(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + CodecQ spatialQuality; +#ifndef GraphicsExportSetCompressionQuality + PyMac_PRECHECK(GraphicsExportSetCompressionQuality); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + CmpObj_Convert, &ci, + &spatialQuality)) + return NULL; + _rv = GraphicsExportSetCompressionQuality(ci, + spatialQuality); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetCompressionQuality(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + CodecQ spatialQuality; +#ifndef GraphicsExportGetCompressionQuality + PyMac_PRECHECK(GraphicsExportGetCompressionQuality); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetCompressionQuality(ci, + &spatialQuality); + _res = Py_BuildValue("ll", + _rv, + spatialQuality); + return _res; +} + +static PyObject *Qt_GraphicsExportSetResolution(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Fixed horizontalResolution; + Fixed verticalResolution; +#ifndef GraphicsExportSetResolution + PyMac_PRECHECK(GraphicsExportSetResolution); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + CmpObj_Convert, &ci, + PyMac_GetFixed, &horizontalResolution, + PyMac_GetFixed, &verticalResolution)) + return NULL; + _rv = GraphicsExportSetResolution(ci, + horizontalResolution, + verticalResolution); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetResolution(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Fixed horizontalResolution; + Fixed verticalResolution; +#ifndef GraphicsExportGetResolution + PyMac_PRECHECK(GraphicsExportGetResolution); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetResolution(ci, + &horizontalResolution, + &verticalResolution); + _res = Py_BuildValue("lO&O&", + _rv, + PyMac_BuildFixed, horizontalResolution, + PyMac_BuildFixed, verticalResolution); + return _res; +} + +static PyObject *Qt_GraphicsExportSetDepth(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + long depth; +#ifndef GraphicsExportSetDepth + PyMac_PRECHECK(GraphicsExportSetDepth); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + CmpObj_Convert, &ci, + &depth)) + return NULL; + _rv = GraphicsExportSetDepth(ci, + depth); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetDepth(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + long depth; +#ifndef GraphicsExportGetDepth + PyMac_PRECHECK(GraphicsExportGetDepth); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetDepth(ci, + &depth); + _res = Py_BuildValue("ll", + _rv, + depth); + return _res; +} + +static PyObject *Qt_GraphicsExportSetColorSyncProfile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Handle colorSyncProfile; +#ifndef GraphicsExportSetColorSyncProfile + PyMac_PRECHECK(GraphicsExportSetColorSyncProfile); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + ResObj_Convert, &colorSyncProfile)) + return NULL; + _rv = GraphicsExportSetColorSyncProfile(ci, + colorSyncProfile); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetColorSyncProfile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Handle colorSyncProfile; +#ifndef GraphicsExportGetColorSyncProfile + PyMac_PRECHECK(GraphicsExportGetColorSyncProfile); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetColorSyncProfile(ci, + &colorSyncProfile); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, colorSyncProfile); + return _res; +} + +static PyObject *Qt_GraphicsExportSetInputDataReference(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Handle dataRef; + OSType dataRefType; + ImageDescriptionHandle desc; +#ifndef GraphicsExportSetInputDataReference + PyMac_PRECHECK(GraphicsExportSetInputDataReference); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&O&", + CmpObj_Convert, &ci, + ResObj_Convert, &dataRef, + PyMac_GetOSType, &dataRefType, + ResObj_Convert, &desc)) + return NULL; + _rv = GraphicsExportSetInputDataReference(ci, + dataRef, + dataRefType, + desc); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetInputDataReference(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Handle dataRef; + OSType dataRefType; +#ifndef GraphicsExportGetInputDataReference + PyMac_PRECHECK(GraphicsExportGetInputDataReference); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetInputDataReference(ci, + &dataRef, + &dataRefType); + _res = Py_BuildValue("lO&O&", + _rv, + ResObj_New, dataRef, + PyMac_BuildOSType, dataRefType); + return _res; +} + +static PyObject *Qt_GraphicsExportSetInputFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + FSSpec theFile; + ImageDescriptionHandle desc; +#ifndef GraphicsExportSetInputFile + PyMac_PRECHECK(GraphicsExportSetInputFile); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + CmpObj_Convert, &ci, + PyMac_GetFSSpec, &theFile, + ResObj_Convert, &desc)) + return NULL; + _rv = GraphicsExportSetInputFile(ci, + &theFile, + desc); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetInputFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + FSSpec theFile; +#ifndef GraphicsExportGetInputFile + PyMac_PRECHECK(GraphicsExportGetInputFile); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + PyMac_GetFSSpec, &theFile)) + return NULL; + _rv = GraphicsExportGetInputFile(ci, + &theFile); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportSetInputHandle(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Handle h; + ImageDescriptionHandle desc; +#ifndef GraphicsExportSetInputHandle + PyMac_PRECHECK(GraphicsExportSetInputHandle); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + CmpObj_Convert, &ci, + ResObj_Convert, &h, + ResObj_Convert, &desc)) + return NULL; + _rv = GraphicsExportSetInputHandle(ci, + h, + desc); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetInputHandle(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Handle h; +#ifndef GraphicsExportGetInputHandle + PyMac_PRECHECK(GraphicsExportGetInputHandle); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetInputHandle(ci, + &h); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, h); + return _res; +} + +static PyObject *Qt_GraphicsExportSetInputPtr(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Ptr p; + unsigned long size; + ImageDescriptionHandle desc; +#ifndef GraphicsExportSetInputPtr + PyMac_PRECHECK(GraphicsExportSetInputPtr); +#endif + if (!PyArg_ParseTuple(_args, "O&slO&", + CmpObj_Convert, &ci, + &p, + &size, + ResObj_Convert, &desc)) + return NULL; + _rv = GraphicsExportSetInputPtr(ci, + p, + size, + desc); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportSetInputGraphicsImporter(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + GraphicsImportComponent grip; +#ifndef GraphicsExportSetInputGraphicsImporter + PyMac_PRECHECK(GraphicsExportSetInputGraphicsImporter); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + CmpObj_Convert, &grip)) + return NULL; + _rv = GraphicsExportSetInputGraphicsImporter(ci, + grip); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetInputGraphicsImporter(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + GraphicsImportComponent grip; +#ifndef GraphicsExportGetInputGraphicsImporter + PyMac_PRECHECK(GraphicsExportGetInputGraphicsImporter); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetInputGraphicsImporter(ci, + &grip); + _res = Py_BuildValue("lO&", + _rv, + CmpObj_New, grip); + return _res; +} + +static PyObject *Qt_GraphicsExportSetInputPicture(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + PicHandle picture; +#ifndef GraphicsExportSetInputPicture + PyMac_PRECHECK(GraphicsExportSetInputPicture); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + ResObj_Convert, &picture)) + return NULL; + _rv = GraphicsExportSetInputPicture(ci, + picture); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetInputPicture(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + PicHandle picture; +#ifndef GraphicsExportGetInputPicture + PyMac_PRECHECK(GraphicsExportGetInputPicture); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetInputPicture(ci, + &picture); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, picture); + return _res; +} + +static PyObject *Qt_GraphicsExportSetInputGWorld(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + GWorldPtr gworld; +#ifndef GraphicsExportSetInputGWorld + PyMac_PRECHECK(GraphicsExportSetInputGWorld); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + GWorldObj_Convert, &gworld)) + return NULL; + _rv = GraphicsExportSetInputGWorld(ci, + gworld); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetInputGWorld(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + GWorldPtr gworld; +#ifndef GraphicsExportGetInputGWorld + PyMac_PRECHECK(GraphicsExportGetInputGWorld); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetInputGWorld(ci, + &gworld); + _res = Py_BuildValue("lO&", + _rv, + GWorldObj_New, gworld); + return _res; +} + +static PyObject *Qt_GraphicsExportSetInputPixmap(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + PixMapHandle pixmap; +#ifndef GraphicsExportSetInputPixmap + PyMac_PRECHECK(GraphicsExportSetInputPixmap); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + ResObj_Convert, &pixmap)) + return NULL; + _rv = GraphicsExportSetInputPixmap(ci, + pixmap); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetInputPixmap(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + PixMapHandle pixmap; +#ifndef GraphicsExportGetInputPixmap + PyMac_PRECHECK(GraphicsExportGetInputPixmap); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetInputPixmap(ci, + &pixmap); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, pixmap); + return _res; +} + +static PyObject *Qt_GraphicsExportSetInputOffsetAndLimit(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + unsigned long offset; + unsigned long limit; +#ifndef GraphicsExportSetInputOffsetAndLimit + PyMac_PRECHECK(GraphicsExportSetInputOffsetAndLimit); +#endif + if (!PyArg_ParseTuple(_args, "O&ll", + CmpObj_Convert, &ci, + &offset, + &limit)) + return NULL; + _rv = GraphicsExportSetInputOffsetAndLimit(ci, + offset, + limit); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetInputOffsetAndLimit(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + unsigned long offset; + unsigned long limit; +#ifndef GraphicsExportGetInputOffsetAndLimit + PyMac_PRECHECK(GraphicsExportGetInputOffsetAndLimit); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetInputOffsetAndLimit(ci, + &offset, + &limit); + _res = Py_BuildValue("lll", + _rv, + offset, + limit); + return _res; +} + +static PyObject *Qt_GraphicsExportMayExporterReadInputData(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Boolean mayReadInputData; +#ifndef GraphicsExportMayExporterReadInputData + PyMac_PRECHECK(GraphicsExportMayExporterReadInputData); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportMayExporterReadInputData(ci, + &mayReadInputData); + _res = Py_BuildValue("lb", + _rv, + mayReadInputData); + return _res; +} + +static PyObject *Qt_GraphicsExportGetInputDataSize(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + unsigned long size; +#ifndef GraphicsExportGetInputDataSize + PyMac_PRECHECK(GraphicsExportGetInputDataSize); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetInputDataSize(ci, + &size); + _res = Py_BuildValue("ll", + _rv, + size); + return _res; +} + +static PyObject *Qt_GraphicsExportReadInputData(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + void * dataPtr; + unsigned long dataOffset; + unsigned long dataSize; +#ifndef GraphicsExportReadInputData + PyMac_PRECHECK(GraphicsExportReadInputData); +#endif + if (!PyArg_ParseTuple(_args, "O&sll", + CmpObj_Convert, &ci, + &dataPtr, + &dataOffset, + &dataSize)) + return NULL; + _rv = GraphicsExportReadInputData(ci, + dataPtr, + dataOffset, + dataSize); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetInputImageDescription(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + ImageDescriptionHandle desc; +#ifndef GraphicsExportGetInputImageDescription + PyMac_PRECHECK(GraphicsExportGetInputImageDescription); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetInputImageDescription(ci, + &desc); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, desc); + return _res; +} + +static PyObject *Qt_GraphicsExportGetInputImageDimensions(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Rect dimensions; +#ifndef GraphicsExportGetInputImageDimensions + PyMac_PRECHECK(GraphicsExportGetInputImageDimensions); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetInputImageDimensions(ci, + &dimensions); + _res = Py_BuildValue("lO&", + _rv, + PyMac_BuildRect, &dimensions); + return _res; +} + +static PyObject *Qt_GraphicsExportGetInputImageDepth(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + long inputDepth; +#ifndef GraphicsExportGetInputImageDepth + PyMac_PRECHECK(GraphicsExportGetInputImageDepth); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetInputImageDepth(ci, + &inputDepth); + _res = Py_BuildValue("ll", + _rv, + inputDepth); + return _res; +} + +static PyObject *Qt_GraphicsExportDrawInputImage(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + CGrafPtr gw; + GDHandle gd; + Rect srcRect; + Rect dstRect; +#ifndef GraphicsExportDrawInputImage + PyMac_PRECHECK(GraphicsExportDrawInputImage); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&O&O&", + CmpObj_Convert, &ci, + GrafObj_Convert, &gw, + OptResObj_Convert, &gd, + PyMac_GetRect, &srcRect, + PyMac_GetRect, &dstRect)) + return NULL; + _rv = GraphicsExportDrawInputImage(ci, + gw, + gd, + &srcRect, + &dstRect); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportSetOutputDataReference(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Handle dataRef; + OSType dataRefType; +#ifndef GraphicsExportSetOutputDataReference + PyMac_PRECHECK(GraphicsExportSetOutputDataReference); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + CmpObj_Convert, &ci, + ResObj_Convert, &dataRef, + PyMac_GetOSType, &dataRefType)) + return NULL; + _rv = GraphicsExportSetOutputDataReference(ci, + dataRef, + dataRefType); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetOutputDataReference(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Handle dataRef; + OSType dataRefType; +#ifndef GraphicsExportGetOutputDataReference + PyMac_PRECHECK(GraphicsExportGetOutputDataReference); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetOutputDataReference(ci, + &dataRef, + &dataRefType); + _res = Py_BuildValue("lO&O&", + _rv, + ResObj_New, dataRef, + PyMac_BuildOSType, dataRefType); + return _res; +} + +static PyObject *Qt_GraphicsExportSetOutputFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + FSSpec theFile; +#ifndef GraphicsExportSetOutputFile + PyMac_PRECHECK(GraphicsExportSetOutputFile); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + PyMac_GetFSSpec, &theFile)) + return NULL; + _rv = GraphicsExportSetOutputFile(ci, + &theFile); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetOutputFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + FSSpec theFile; +#ifndef GraphicsExportGetOutputFile + PyMac_PRECHECK(GraphicsExportGetOutputFile); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + PyMac_GetFSSpec, &theFile)) + return NULL; + _rv = GraphicsExportGetOutputFile(ci, + &theFile); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportSetOutputHandle(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Handle h; +#ifndef GraphicsExportSetOutputHandle + PyMac_PRECHECK(GraphicsExportSetOutputHandle); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CmpObj_Convert, &ci, + ResObj_Convert, &h)) + return NULL; + _rv = GraphicsExportSetOutputHandle(ci, + h); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetOutputHandle(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Handle h; +#ifndef GraphicsExportGetOutputHandle + PyMac_PRECHECK(GraphicsExportGetOutputHandle); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetOutputHandle(ci, + &h); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, h); + return _res; +} + +static PyObject *Qt_GraphicsExportSetOutputOffsetAndMaxSize(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + unsigned long offset; + unsigned long maxSize; + Boolean truncateFile; +#ifndef GraphicsExportSetOutputOffsetAndMaxSize + PyMac_PRECHECK(GraphicsExportSetOutputOffsetAndMaxSize); +#endif + if (!PyArg_ParseTuple(_args, "O&llb", + CmpObj_Convert, &ci, + &offset, + &maxSize, + &truncateFile)) + return NULL; + _rv = GraphicsExportSetOutputOffsetAndMaxSize(ci, + offset, + maxSize, + truncateFile); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetOutputOffsetAndMaxSize(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + unsigned long offset; + unsigned long maxSize; + Boolean truncateFile; +#ifndef GraphicsExportGetOutputOffsetAndMaxSize + PyMac_PRECHECK(GraphicsExportGetOutputOffsetAndMaxSize); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetOutputOffsetAndMaxSize(ci, + &offset, + &maxSize, + &truncateFile); + _res = Py_BuildValue("lllb", + _rv, + offset, + maxSize, + truncateFile); + return _res; +} + +static PyObject *Qt_GraphicsExportSetOutputFileTypeAndCreator(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + OSType fileType; + OSType fileCreator; +#ifndef GraphicsExportSetOutputFileTypeAndCreator + PyMac_PRECHECK(GraphicsExportSetOutputFileTypeAndCreator); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + CmpObj_Convert, &ci, + PyMac_GetOSType, &fileType, + PyMac_GetOSType, &fileCreator)) + return NULL; + _rv = GraphicsExportSetOutputFileTypeAndCreator(ci, + fileType, + fileCreator); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetOutputFileTypeAndCreator(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + OSType fileType; + OSType fileCreator; +#ifndef GraphicsExportGetOutputFileTypeAndCreator + PyMac_PRECHECK(GraphicsExportGetOutputFileTypeAndCreator); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetOutputFileTypeAndCreator(ci, + &fileType, + &fileCreator); + _res = Py_BuildValue("lO&O&", + _rv, + PyMac_BuildOSType, fileType, + PyMac_BuildOSType, fileCreator); + return _res; +} + +static PyObject *Qt_GraphicsExportSetOutputMark(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + unsigned long mark; +#ifndef GraphicsExportSetOutputMark + PyMac_PRECHECK(GraphicsExportSetOutputMark); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + CmpObj_Convert, &ci, + &mark)) + return NULL; + _rv = GraphicsExportSetOutputMark(ci, + mark); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetOutputMark(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + unsigned long mark; +#ifndef GraphicsExportGetOutputMark + PyMac_PRECHECK(GraphicsExportGetOutputMark); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetOutputMark(ci, + &mark); + _res = Py_BuildValue("ll", + _rv, + mark); + return _res; +} + +static PyObject *Qt_GraphicsExportReadOutputData(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + void * dataPtr; + unsigned long dataOffset; + unsigned long dataSize; +#ifndef GraphicsExportReadOutputData + PyMac_PRECHECK(GraphicsExportReadOutputData); +#endif + if (!PyArg_ParseTuple(_args, "O&sll", + CmpObj_Convert, &ci, + &dataPtr, + &dataOffset, + &dataSize)) + return NULL; + _rv = GraphicsExportReadOutputData(ci, + dataPtr, + dataOffset, + dataSize); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportSetThumbnailEnabled(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Boolean enableThumbnail; + long maxThumbnailWidth; + long maxThumbnailHeight; +#ifndef GraphicsExportSetThumbnailEnabled + PyMac_PRECHECK(GraphicsExportSetThumbnailEnabled); +#endif + if (!PyArg_ParseTuple(_args, "O&bll", + CmpObj_Convert, &ci, + &enableThumbnail, + &maxThumbnailWidth, + &maxThumbnailHeight)) + return NULL; + _rv = GraphicsExportSetThumbnailEnabled(ci, + enableThumbnail, + maxThumbnailWidth, + maxThumbnailHeight); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetThumbnailEnabled(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Boolean thumbnailEnabled; + long maxThumbnailWidth; + long maxThumbnailHeight; +#ifndef GraphicsExportGetThumbnailEnabled + PyMac_PRECHECK(GraphicsExportGetThumbnailEnabled); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetThumbnailEnabled(ci, + &thumbnailEnabled, + &maxThumbnailWidth, + &maxThumbnailHeight); + _res = Py_BuildValue("lbll", + _rv, + thumbnailEnabled, + maxThumbnailWidth, + maxThumbnailHeight); + return _res; +} + +static PyObject *Qt_GraphicsExportSetExifEnabled(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Boolean enableExif; +#ifndef GraphicsExportSetExifEnabled + PyMac_PRECHECK(GraphicsExportSetExifEnabled); +#endif + if (!PyArg_ParseTuple(_args, "O&b", + CmpObj_Convert, &ci, + &enableExif)) + return NULL; + _rv = GraphicsExportSetExifEnabled(ci, + enableExif); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_GraphicsExportGetExifEnabled(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + GraphicsExportComponent ci; + Boolean exifEnabled; +#ifndef GraphicsExportGetExifEnabled + PyMac_PRECHECK(GraphicsExportGetExifEnabled); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &ci)) + return NULL; + _rv = GraphicsExportGetExifEnabled(ci, + &exifEnabled); + _res = Py_BuildValue("lb", + _rv, + exifEnabled); + return _res; +} + +static PyObject *Qt_ImageTranscoderBeginSequence(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + ImageTranscoderComponent itc; + ImageDescriptionHandle srcDesc; + ImageDescriptionHandle dstDesc; + void * data; + long dataSize; +#ifndef ImageTranscoderBeginSequence + PyMac_PRECHECK(ImageTranscoderBeginSequence); +#endif + if (!PyArg_ParseTuple(_args, "O&O&sl", + CmpObj_Convert, &itc, + ResObj_Convert, &srcDesc, + &data, + &dataSize)) + return NULL; + _rv = ImageTranscoderBeginSequence(itc, + srcDesc, + &dstDesc, + data, + dataSize); + _res = Py_BuildValue("lO&", + _rv, + ResObj_New, dstDesc); + return _res; +} + +static PyObject *Qt_ImageTranscoderDisposeData(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + ImageTranscoderComponent itc; + void * dstData; +#ifndef ImageTranscoderDisposeData + PyMac_PRECHECK(ImageTranscoderDisposeData); +#endif + if (!PyArg_ParseTuple(_args, "O&s", + CmpObj_Convert, &itc, + &dstData)) + return NULL; + _rv = ImageTranscoderDisposeData(itc, + dstData); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *Qt_ImageTranscoderEndSequence(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ComponentResult _rv; + ImageTranscoderComponent itc; +#ifndef ImageTranscoderEndSequence + PyMac_PRECHECK(ImageTranscoderEndSequence); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CmpObj_Convert, &itc)) + return NULL; + _rv = ImageTranscoderEndSequence(itc); + _res = Py_BuildValue("l", + _rv); + return _res; +} + static PyObject *Qt_AlignWindow(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; @@ -10483,6 +14389,366 @@ static PyMethodDef Qt_methods[] = { PyDoc_STR("(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)")}, {"MusicMediaGetIndexedTunePlayer", (PyCFunction)Qt_MusicMediaGetIndexedTunePlayer, 1, PyDoc_STR("(ComponentInstance ti, long sampleDescIndex) -> (ComponentResult _rv, ComponentInstance tp)")}, + {"CodecManagerVersion", (PyCFunction)Qt_CodecManagerVersion, 1, + PyDoc_STR("() -> (long version)")}, + {"GetMaxCompressionSize", (PyCFunction)Qt_GetMaxCompressionSize, 1, + PyDoc_STR("(PixMapHandle src, Rect srcRect, short colorDepth, CodecQ quality, CodecType cType, CompressorComponent codec) -> (long size)")}, + {"GetCompressionTime", (PyCFunction)Qt_GetCompressionTime, 1, + PyDoc_STR("(PixMapHandle src, Rect srcRect, short colorDepth, CodecType cType, CompressorComponent codec) -> (CodecQ spatialQuality, CodecQ temporalQuality, unsigned long compressTime)")}, + {"CompressImage", (PyCFunction)Qt_CompressImage, 1, + PyDoc_STR("(PixMapHandle src, Rect srcRect, CodecQ quality, CodecType cType, ImageDescriptionHandle desc, Ptr data) -> None")}, + {"DecompressImage", (PyCFunction)Qt_DecompressImage, 1, + PyDoc_STR("(Ptr data, ImageDescriptionHandle desc, PixMapHandle dst, Rect srcRect, Rect dstRect, short mode, RgnHandle mask) -> None")}, + {"GetSimilarity", (PyCFunction)Qt_GetSimilarity, 1, + PyDoc_STR("(PixMapHandle src, Rect srcRect, ImageDescriptionHandle desc, Ptr data) -> (Fixed similarity)")}, + {"GetImageDescriptionCTable", (PyCFunction)Qt_GetImageDescriptionCTable, 1, + PyDoc_STR("(ImageDescriptionHandle desc) -> (CTabHandle ctable)")}, + {"SetImageDescriptionCTable", (PyCFunction)Qt_SetImageDescriptionCTable, 1, + PyDoc_STR("(ImageDescriptionHandle desc, CTabHandle ctable) -> None")}, + {"GetImageDescriptionExtension", (PyCFunction)Qt_GetImageDescriptionExtension, 1, + PyDoc_STR("(ImageDescriptionHandle desc, long idType, long index) -> (Handle extension)")}, + {"AddImageDescriptionExtension", (PyCFunction)Qt_AddImageDescriptionExtension, 1, + PyDoc_STR("(ImageDescriptionHandle desc, Handle extension, long idType) -> None")}, + {"RemoveImageDescriptionExtension", (PyCFunction)Qt_RemoveImageDescriptionExtension, 1, + PyDoc_STR("(ImageDescriptionHandle desc, long idType, long index) -> None")}, + {"CountImageDescriptionExtensionType", (PyCFunction)Qt_CountImageDescriptionExtensionType, 1, + PyDoc_STR("(ImageDescriptionHandle desc, long idType) -> (long count)")}, + {"GetNextImageDescriptionExtensionType", (PyCFunction)Qt_GetNextImageDescriptionExtensionType, 1, + PyDoc_STR("(ImageDescriptionHandle desc) -> (long idType)")}, + {"FindCodec", (PyCFunction)Qt_FindCodec, 1, + PyDoc_STR("(CodecType cType, CodecComponent specCodec) -> (CompressorComponent compressor, DecompressorComponent decompressor)")}, + {"CompressPicture", (PyCFunction)Qt_CompressPicture, 1, + PyDoc_STR("(PicHandle srcPicture, PicHandle dstPicture, CodecQ quality, CodecType cType) -> None")}, + {"CompressPictureFile", (PyCFunction)Qt_CompressPictureFile, 1, + PyDoc_STR("(short srcRefNum, short dstRefNum, CodecQ quality, CodecType cType) -> None")}, + {"ConvertImage", (PyCFunction)Qt_ConvertImage, 1, + PyDoc_STR("(ImageDescriptionHandle srcDD, Ptr srcData, short colorDepth, CTabHandle ctable, CodecQ accuracy, CodecQ quality, CodecType cType, CodecComponent codec, ImageDescriptionHandle dstDD, Ptr dstData) -> None")}, + {"AddFilePreview", (PyCFunction)Qt_AddFilePreview, 1, + PyDoc_STR("(short resRefNum, OSType previewType, Handle previewData) -> None")}, + {"GetBestDeviceRect", (PyCFunction)Qt_GetBestDeviceRect, 1, + PyDoc_STR("() -> (GDHandle gdh, Rect rp)")}, + {"GDHasScale", (PyCFunction)Qt_GDHasScale, 1, + PyDoc_STR("(GDHandle gdh, short depth) -> (Fixed scale)")}, + {"GDGetScale", (PyCFunction)Qt_GDGetScale, 1, + PyDoc_STR("(GDHandle gdh) -> (Fixed scale, short flags)")}, + {"GDSetScale", (PyCFunction)Qt_GDSetScale, 1, + PyDoc_STR("(GDHandle gdh, Fixed scale, short flags) -> None")}, + {"GetGraphicsImporterForFile", (PyCFunction)Qt_GetGraphicsImporterForFile, 1, + PyDoc_STR("(FSSpec theFile) -> (ComponentInstance gi)")}, + {"GetGraphicsImporterForDataRef", (PyCFunction)Qt_GetGraphicsImporterForDataRef, 1, + PyDoc_STR("(Handle dataRef, OSType dataRefType) -> (ComponentInstance gi)")}, + {"GetGraphicsImporterForFileWithFlags", (PyCFunction)Qt_GetGraphicsImporterForFileWithFlags, 1, + PyDoc_STR("(FSSpec theFile, long flags) -> (ComponentInstance gi)")}, + {"GetGraphicsImporterForDataRefWithFlags", (PyCFunction)Qt_GetGraphicsImporterForDataRefWithFlags, 1, + PyDoc_STR("(Handle dataRef, OSType dataRefType, long flags) -> (ComponentInstance gi)")}, + {"MakeImageDescriptionForPixMap", (PyCFunction)Qt_MakeImageDescriptionForPixMap, 1, + PyDoc_STR("(PixMapHandle pixmap) -> (ImageDescriptionHandle idh)")}, + {"MakeImageDescriptionForEffect", (PyCFunction)Qt_MakeImageDescriptionForEffect, 1, + PyDoc_STR("(OSType effectType) -> (ImageDescriptionHandle idh)")}, + {"QTGetPixelSize", (PyCFunction)Qt_QTGetPixelSize, 1, + PyDoc_STR("(OSType PixelFormat) -> (short _rv)")}, + {"QTGetPixelFormatDepthForImageDescription", (PyCFunction)Qt_QTGetPixelFormatDepthForImageDescription, 1, + PyDoc_STR("(OSType PixelFormat) -> (short _rv)")}, + {"QTGetPixMapHandleRowBytes", (PyCFunction)Qt_QTGetPixMapHandleRowBytes, 1, + PyDoc_STR("(PixMapHandle pm) -> (long _rv)")}, + {"QTSetPixMapHandleRowBytes", (PyCFunction)Qt_QTSetPixMapHandleRowBytes, 1, + PyDoc_STR("(PixMapHandle pm, long rowBytes) -> None")}, + {"QTGetPixMapHandleGammaLevel", (PyCFunction)Qt_QTGetPixMapHandleGammaLevel, 1, + PyDoc_STR("(PixMapHandle pm) -> (Fixed _rv)")}, + {"QTSetPixMapHandleGammaLevel", (PyCFunction)Qt_QTSetPixMapHandleGammaLevel, 1, + PyDoc_STR("(PixMapHandle pm, Fixed gammaLevel) -> None")}, + {"QTGetPixMapHandleRequestedGammaLevel", (PyCFunction)Qt_QTGetPixMapHandleRequestedGammaLevel, 1, + PyDoc_STR("(PixMapHandle pm) -> (Fixed _rv)")}, + {"QTSetPixMapHandleRequestedGammaLevel", (PyCFunction)Qt_QTSetPixMapHandleRequestedGammaLevel, 1, + PyDoc_STR("(PixMapHandle pm, Fixed requestedGammaLevel) -> None")}, + {"CompAdd", (PyCFunction)Qt_CompAdd, 1, + PyDoc_STR("() -> (wide src, wide dst)")}, + {"CompSub", (PyCFunction)Qt_CompSub, 1, + PyDoc_STR("() -> (wide src, wide dst)")}, + {"CompNeg", (PyCFunction)Qt_CompNeg, 1, + PyDoc_STR("() -> (wide dst)")}, + {"CompShift", (PyCFunction)Qt_CompShift, 1, + PyDoc_STR("(short shift) -> (wide src)")}, + {"CompMul", (PyCFunction)Qt_CompMul, 1, + PyDoc_STR("(long src1, long src2) -> (wide dst)")}, + {"CompDiv", (PyCFunction)Qt_CompDiv, 1, + PyDoc_STR("(long denominator) -> (long _rv, wide numerator, long remainder)")}, + {"CompFixMul", (PyCFunction)Qt_CompFixMul, 1, + PyDoc_STR("(Fixed fixSrc) -> (wide compSrc, wide compDst)")}, + {"CompMulDiv", (PyCFunction)Qt_CompMulDiv, 1, + PyDoc_STR("(long mul, long divisor) -> (wide co)")}, + {"CompMulDivTrunc", (PyCFunction)Qt_CompMulDivTrunc, 1, + PyDoc_STR("(long mul, long divisor) -> (wide co, long remainder)")}, + {"CompCompare", (PyCFunction)Qt_CompCompare, 1, + PyDoc_STR("(wide a, wide minusb) -> (long _rv)")}, + {"CompSquareRoot", (PyCFunction)Qt_CompSquareRoot, 1, + PyDoc_STR("(wide src) -> (unsigned long _rv)")}, + {"FixMulDiv", (PyCFunction)Qt_FixMulDiv, 1, + PyDoc_STR("(Fixed src, Fixed mul, Fixed divisor) -> (Fixed _rv)")}, + {"UnsignedFixMulDiv", (PyCFunction)Qt_UnsignedFixMulDiv, 1, + PyDoc_STR("(Fixed src, Fixed mul, Fixed divisor) -> (Fixed _rv)")}, + {"FixExp2", (PyCFunction)Qt_FixExp2, 1, + PyDoc_STR("(Fixed src) -> (Fixed _rv)")}, + {"FixLog2", (PyCFunction)Qt_FixLog2, 1, + PyDoc_STR("(Fixed src) -> (Fixed _rv)")}, + {"FixPow", (PyCFunction)Qt_FixPow, 1, + PyDoc_STR("(Fixed base, Fixed exp) -> (Fixed _rv)")}, + {"GraphicsImportSetDataReference", (PyCFunction)Qt_GraphicsImportSetDataReference, 1, + PyDoc_STR("(GraphicsImportComponent ci, Handle dataRef, OSType dataReType) -> (ComponentResult _rv)")}, + {"GraphicsImportGetDataReference", (PyCFunction)Qt_GraphicsImportGetDataReference, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Handle dataRef, OSType dataReType)")}, + {"GraphicsImportSetDataFile", (PyCFunction)Qt_GraphicsImportSetDataFile, 1, + PyDoc_STR("(GraphicsImportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")}, + {"GraphicsImportGetDataFile", (PyCFunction)Qt_GraphicsImportGetDataFile, 1, + PyDoc_STR("(GraphicsImportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")}, + {"GraphicsImportSetDataHandle", (PyCFunction)Qt_GraphicsImportSetDataHandle, 1, + PyDoc_STR("(GraphicsImportComponent ci, Handle h) -> (ComponentResult _rv)")}, + {"GraphicsImportGetDataHandle", (PyCFunction)Qt_GraphicsImportGetDataHandle, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Handle h)")}, + {"GraphicsImportGetImageDescription", (PyCFunction)Qt_GraphicsImportGetImageDescription, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, ImageDescriptionHandle desc)")}, + {"GraphicsImportGetDataOffsetAndSize", (PyCFunction)Qt_GraphicsImportGetDataOffsetAndSize, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, unsigned long offset, unsigned long size)")}, + {"GraphicsImportReadData", (PyCFunction)Qt_GraphicsImportReadData, 1, + PyDoc_STR("(GraphicsImportComponent ci, void * dataPtr, unsigned long dataOffset, unsigned long dataSize) -> (ComponentResult _rv)")}, + {"GraphicsImportSetClip", (PyCFunction)Qt_GraphicsImportSetClip, 1, + PyDoc_STR("(GraphicsImportComponent ci, RgnHandle clipRgn) -> (ComponentResult _rv)")}, + {"GraphicsImportGetClip", (PyCFunction)Qt_GraphicsImportGetClip, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, RgnHandle clipRgn)")}, + {"GraphicsImportSetSourceRect", (PyCFunction)Qt_GraphicsImportSetSourceRect, 1, + PyDoc_STR("(GraphicsImportComponent ci, Rect sourceRect) -> (ComponentResult _rv)")}, + {"GraphicsImportGetSourceRect", (PyCFunction)Qt_GraphicsImportGetSourceRect, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect sourceRect)")}, + {"GraphicsImportGetNaturalBounds", (PyCFunction)Qt_GraphicsImportGetNaturalBounds, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect naturalBounds)")}, + {"GraphicsImportDraw", (PyCFunction)Qt_GraphicsImportDraw, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv)")}, + {"GraphicsImportSetGWorld", (PyCFunction)Qt_GraphicsImportSetGWorld, 1, + PyDoc_STR("(GraphicsImportComponent ci, CGrafPtr port, GDHandle gd) -> (ComponentResult _rv)")}, + {"GraphicsImportGetGWorld", (PyCFunction)Qt_GraphicsImportGetGWorld, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, CGrafPtr port, GDHandle gd)")}, + {"GraphicsImportSetBoundsRect", (PyCFunction)Qt_GraphicsImportSetBoundsRect, 1, + PyDoc_STR("(GraphicsImportComponent ci, Rect bounds) -> (ComponentResult _rv)")}, + {"GraphicsImportGetBoundsRect", (PyCFunction)Qt_GraphicsImportGetBoundsRect, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect bounds)")}, + {"GraphicsImportSaveAsPicture", (PyCFunction)Qt_GraphicsImportSaveAsPicture, 1, + PyDoc_STR("(GraphicsImportComponent ci, FSSpec fss, ScriptCode scriptTag) -> (ComponentResult _rv)")}, + {"GraphicsImportSetGraphicsMode", (PyCFunction)Qt_GraphicsImportSetGraphicsMode, 1, + PyDoc_STR("(GraphicsImportComponent ci, long graphicsMode, RGBColor opColor) -> (ComponentResult _rv)")}, + {"GraphicsImportGetGraphicsMode", (PyCFunction)Qt_GraphicsImportGetGraphicsMode, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, long graphicsMode, RGBColor opColor)")}, + {"GraphicsImportSetQuality", (PyCFunction)Qt_GraphicsImportSetQuality, 1, + PyDoc_STR("(GraphicsImportComponent ci, CodecQ quality) -> (ComponentResult _rv)")}, + {"GraphicsImportGetQuality", (PyCFunction)Qt_GraphicsImportGetQuality, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, CodecQ quality)")}, + {"GraphicsImportSaveAsQuickTimeImageFile", (PyCFunction)Qt_GraphicsImportSaveAsQuickTimeImageFile, 1, + PyDoc_STR("(GraphicsImportComponent ci, FSSpec fss, ScriptCode scriptTag) -> (ComponentResult _rv)")}, + {"GraphicsImportSetDataReferenceOffsetAndLimit", (PyCFunction)Qt_GraphicsImportSetDataReferenceOffsetAndLimit, 1, + PyDoc_STR("(GraphicsImportComponent ci, unsigned long offset, unsigned long limit) -> (ComponentResult _rv)")}, + {"GraphicsImportGetDataReferenceOffsetAndLimit", (PyCFunction)Qt_GraphicsImportGetDataReferenceOffsetAndLimit, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, unsigned long offset, unsigned long limit)")}, + {"GraphicsImportGetAliasedDataReference", (PyCFunction)Qt_GraphicsImportGetAliasedDataReference, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType)")}, + {"GraphicsImportValidate", (PyCFunction)Qt_GraphicsImportValidate, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Boolean valid)")}, + {"GraphicsImportGetMetaData", (PyCFunction)Qt_GraphicsImportGetMetaData, 1, + PyDoc_STR("(GraphicsImportComponent ci, void * userData) -> (ComponentResult _rv)")}, + {"GraphicsImportGetMIMETypeList", (PyCFunction)Qt_GraphicsImportGetMIMETypeList, 1, + PyDoc_STR("(GraphicsImportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")}, + {"GraphicsImportDoesDrawAllPixels", (PyCFunction)Qt_GraphicsImportDoesDrawAllPixels, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, short drawsAllPixels)")}, + {"GraphicsImportGetAsPicture", (PyCFunction)Qt_GraphicsImportGetAsPicture, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, PicHandle picture)")}, + {"GraphicsImportExportImageFile", (PyCFunction)Qt_GraphicsImportExportImageFile, 1, + PyDoc_STR("(GraphicsImportComponent ci, OSType fileType, OSType fileCreator, FSSpec fss, ScriptCode scriptTag) -> (ComponentResult _rv)")}, + {"GraphicsImportGetExportImageTypeList", (PyCFunction)Qt_GraphicsImportGetExportImageTypeList, 1, + PyDoc_STR("(GraphicsImportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")}, + {"GraphicsImportGetExportSettingsAsAtomContainer", (PyCFunction)Qt_GraphicsImportGetExportSettingsAsAtomContainer, 1, + PyDoc_STR("(GraphicsImportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")}, + {"GraphicsImportSetExportSettingsFromAtomContainer", (PyCFunction)Qt_GraphicsImportSetExportSettingsFromAtomContainer, 1, + PyDoc_STR("(GraphicsImportComponent ci, void * qtAtomContainer) -> (ComponentResult _rv)")}, + {"GraphicsImportGetImageCount", (PyCFunction)Qt_GraphicsImportGetImageCount, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, unsigned long imageCount)")}, + {"GraphicsImportSetImageIndex", (PyCFunction)Qt_GraphicsImportSetImageIndex, 1, + PyDoc_STR("(GraphicsImportComponent ci, unsigned long imageIndex) -> (ComponentResult _rv)")}, + {"GraphicsImportGetImageIndex", (PyCFunction)Qt_GraphicsImportGetImageIndex, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, unsigned long imageIndex)")}, + {"GraphicsImportGetDataOffsetAndSize64", (PyCFunction)Qt_GraphicsImportGetDataOffsetAndSize64, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, wide offset, wide size)")}, + {"GraphicsImportReadData64", (PyCFunction)Qt_GraphicsImportReadData64, 1, + PyDoc_STR("(GraphicsImportComponent ci, void * dataPtr, wide dataOffset, unsigned long dataSize) -> (ComponentResult _rv)")}, + {"GraphicsImportSetDataReferenceOffsetAndLimit64", (PyCFunction)Qt_GraphicsImportSetDataReferenceOffsetAndLimit64, 1, + PyDoc_STR("(GraphicsImportComponent ci, wide offset, wide limit) -> (ComponentResult _rv)")}, + {"GraphicsImportGetDataReferenceOffsetAndLimit64", (PyCFunction)Qt_GraphicsImportGetDataReferenceOffsetAndLimit64, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, wide offset, wide limit)")}, + {"GraphicsImportGetDefaultClip", (PyCFunction)Qt_GraphicsImportGetDefaultClip, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, RgnHandle defaultRgn)")}, + {"GraphicsImportGetDefaultGraphicsMode", (PyCFunction)Qt_GraphicsImportGetDefaultGraphicsMode, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, long defaultGraphicsMode, RGBColor defaultOpColor)")}, + {"GraphicsImportGetDefaultSourceRect", (PyCFunction)Qt_GraphicsImportGetDefaultSourceRect, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect defaultSourceRect)")}, + {"GraphicsImportGetColorSyncProfile", (PyCFunction)Qt_GraphicsImportGetColorSyncProfile, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Handle profile)")}, + {"GraphicsImportSetDestRect", (PyCFunction)Qt_GraphicsImportSetDestRect, 1, + PyDoc_STR("(GraphicsImportComponent ci, Rect destRect) -> (ComponentResult _rv)")}, + {"GraphicsImportGetDestRect", (PyCFunction)Qt_GraphicsImportGetDestRect, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect destRect)")}, + {"GraphicsImportSetFlags", (PyCFunction)Qt_GraphicsImportSetFlags, 1, + PyDoc_STR("(GraphicsImportComponent ci, long flags) -> (ComponentResult _rv)")}, + {"GraphicsImportGetFlags", (PyCFunction)Qt_GraphicsImportGetFlags, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, long flags)")}, + {"GraphicsImportGetBaseDataOffsetAndSize64", (PyCFunction)Qt_GraphicsImportGetBaseDataOffsetAndSize64, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, wide offset, wide size)")}, + {"GraphicsImportSetImageIndexToThumbnail", (PyCFunction)Qt_GraphicsImportSetImageIndexToThumbnail, 1, + PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv)")}, + {"GraphicsExportDoExport", (PyCFunction)Qt_GraphicsExportDoExport, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long actualSizeWritten)")}, + {"GraphicsExportCanTranscode", (PyCFunction)Qt_GraphicsExportCanTranscode, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean canTranscode)")}, + {"GraphicsExportDoTranscode", (PyCFunction)Qt_GraphicsExportDoTranscode, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv)")}, + {"GraphicsExportCanUseCompressor", (PyCFunction)Qt_GraphicsExportCanUseCompressor, 1, + PyDoc_STR("(GraphicsExportComponent ci, void * codecSettingsAtomContainerPtr) -> (ComponentResult _rv, Boolean canUseCompressor)")}, + {"GraphicsExportDoUseCompressor", (PyCFunction)Qt_GraphicsExportDoUseCompressor, 1, + PyDoc_STR("(GraphicsExportComponent ci, void * codecSettingsAtomContainer) -> (ComponentResult _rv, ImageDescriptionHandle outDesc)")}, + {"GraphicsExportDoStandaloneExport", (PyCFunction)Qt_GraphicsExportDoStandaloneExport, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv)")}, + {"GraphicsExportGetDefaultFileTypeAndCreator", (PyCFunction)Qt_GraphicsExportGetDefaultFileTypeAndCreator, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, OSType fileType, OSType fileCreator)")}, + {"GraphicsExportGetDefaultFileNameExtension", (PyCFunction)Qt_GraphicsExportGetDefaultFileNameExtension, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, OSType fileNameExtension)")}, + {"GraphicsExportGetMIMETypeList", (PyCFunction)Qt_GraphicsExportGetMIMETypeList, 1, + PyDoc_STR("(GraphicsExportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")}, + {"GraphicsExportSetSettingsFromAtomContainer", (PyCFunction)Qt_GraphicsExportSetSettingsFromAtomContainer, 1, + PyDoc_STR("(GraphicsExportComponent ci, void * qtAtomContainer) -> (ComponentResult _rv)")}, + {"GraphicsExportGetSettingsAsAtomContainer", (PyCFunction)Qt_GraphicsExportGetSettingsAsAtomContainer, 1, + PyDoc_STR("(GraphicsExportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")}, + {"GraphicsExportGetSettingsAsText", (PyCFunction)Qt_GraphicsExportGetSettingsAsText, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle theText)")}, + {"GraphicsExportSetDontRecompress", (PyCFunction)Qt_GraphicsExportSetDontRecompress, 1, + PyDoc_STR("(GraphicsExportComponent ci, Boolean dontRecompress) -> (ComponentResult _rv)")}, + {"GraphicsExportGetDontRecompress", (PyCFunction)Qt_GraphicsExportGetDontRecompress, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean dontRecompress)")}, + {"GraphicsExportSetInterlaceStyle", (PyCFunction)Qt_GraphicsExportSetInterlaceStyle, 1, + PyDoc_STR("(GraphicsExportComponent ci, unsigned long interlaceStyle) -> (ComponentResult _rv)")}, + {"GraphicsExportGetInterlaceStyle", (PyCFunction)Qt_GraphicsExportGetInterlaceStyle, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long interlaceStyle)")}, + {"GraphicsExportSetMetaData", (PyCFunction)Qt_GraphicsExportSetMetaData, 1, + PyDoc_STR("(GraphicsExportComponent ci, void * userData) -> (ComponentResult _rv)")}, + {"GraphicsExportGetMetaData", (PyCFunction)Qt_GraphicsExportGetMetaData, 1, + PyDoc_STR("(GraphicsExportComponent ci, void * userData) -> (ComponentResult _rv)")}, + {"GraphicsExportSetTargetDataSize", (PyCFunction)Qt_GraphicsExportSetTargetDataSize, 1, + PyDoc_STR("(GraphicsExportComponent ci, unsigned long targetDataSize) -> (ComponentResult _rv)")}, + {"GraphicsExportGetTargetDataSize", (PyCFunction)Qt_GraphicsExportGetTargetDataSize, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long targetDataSize)")}, + {"GraphicsExportSetCompressionMethod", (PyCFunction)Qt_GraphicsExportSetCompressionMethod, 1, + PyDoc_STR("(GraphicsExportComponent ci, long compressionMethod) -> (ComponentResult _rv)")}, + {"GraphicsExportGetCompressionMethod", (PyCFunction)Qt_GraphicsExportGetCompressionMethod, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, long compressionMethod)")}, + {"GraphicsExportSetCompressionQuality", (PyCFunction)Qt_GraphicsExportSetCompressionQuality, 1, + PyDoc_STR("(GraphicsExportComponent ci, CodecQ spatialQuality) -> (ComponentResult _rv)")}, + {"GraphicsExportGetCompressionQuality", (PyCFunction)Qt_GraphicsExportGetCompressionQuality, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, CodecQ spatialQuality)")}, + {"GraphicsExportSetResolution", (PyCFunction)Qt_GraphicsExportSetResolution, 1, + PyDoc_STR("(GraphicsExportComponent ci, Fixed horizontalResolution, Fixed verticalResolution) -> (ComponentResult _rv)")}, + {"GraphicsExportGetResolution", (PyCFunction)Qt_GraphicsExportGetResolution, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Fixed horizontalResolution, Fixed verticalResolution)")}, + {"GraphicsExportSetDepth", (PyCFunction)Qt_GraphicsExportSetDepth, 1, + PyDoc_STR("(GraphicsExportComponent ci, long depth) -> (ComponentResult _rv)")}, + {"GraphicsExportGetDepth", (PyCFunction)Qt_GraphicsExportGetDepth, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, long depth)")}, + {"GraphicsExportSetColorSyncProfile", (PyCFunction)Qt_GraphicsExportSetColorSyncProfile, 1, + PyDoc_STR("(GraphicsExportComponent ci, Handle colorSyncProfile) -> (ComponentResult _rv)")}, + {"GraphicsExportGetColorSyncProfile", (PyCFunction)Qt_GraphicsExportGetColorSyncProfile, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle colorSyncProfile)")}, + {"GraphicsExportSetInputDataReference", (PyCFunction)Qt_GraphicsExportSetInputDataReference, 1, + PyDoc_STR("(GraphicsExportComponent ci, Handle dataRef, OSType dataRefType, ImageDescriptionHandle desc) -> (ComponentResult _rv)")}, + {"GraphicsExportGetInputDataReference", (PyCFunction)Qt_GraphicsExportGetInputDataReference, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType)")}, + {"GraphicsExportSetInputFile", (PyCFunction)Qt_GraphicsExportSetInputFile, 1, + PyDoc_STR("(GraphicsExportComponent ci, FSSpec theFile, ImageDescriptionHandle desc) -> (ComponentResult _rv)")}, + {"GraphicsExportGetInputFile", (PyCFunction)Qt_GraphicsExportGetInputFile, 1, + PyDoc_STR("(GraphicsExportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")}, + {"GraphicsExportSetInputHandle", (PyCFunction)Qt_GraphicsExportSetInputHandle, 1, + PyDoc_STR("(GraphicsExportComponent ci, Handle h, ImageDescriptionHandle desc) -> (ComponentResult _rv)")}, + {"GraphicsExportGetInputHandle", (PyCFunction)Qt_GraphicsExportGetInputHandle, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle h)")}, + {"GraphicsExportSetInputPtr", (PyCFunction)Qt_GraphicsExportSetInputPtr, 1, + PyDoc_STR("(GraphicsExportComponent ci, Ptr p, unsigned long size, ImageDescriptionHandle desc) -> (ComponentResult _rv)")}, + {"GraphicsExportSetInputGraphicsImporter", (PyCFunction)Qt_GraphicsExportSetInputGraphicsImporter, 1, + PyDoc_STR("(GraphicsExportComponent ci, GraphicsImportComponent grip) -> (ComponentResult _rv)")}, + {"GraphicsExportGetInputGraphicsImporter", (PyCFunction)Qt_GraphicsExportGetInputGraphicsImporter, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, GraphicsImportComponent grip)")}, + {"GraphicsExportSetInputPicture", (PyCFunction)Qt_GraphicsExportSetInputPicture, 1, + PyDoc_STR("(GraphicsExportComponent ci, PicHandle picture) -> (ComponentResult _rv)")}, + {"GraphicsExportGetInputPicture", (PyCFunction)Qt_GraphicsExportGetInputPicture, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, PicHandle picture)")}, + {"GraphicsExportSetInputGWorld", (PyCFunction)Qt_GraphicsExportSetInputGWorld, 1, + PyDoc_STR("(GraphicsExportComponent ci, GWorldPtr gworld) -> (ComponentResult _rv)")}, + {"GraphicsExportGetInputGWorld", (PyCFunction)Qt_GraphicsExportGetInputGWorld, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, GWorldPtr gworld)")}, + {"GraphicsExportSetInputPixmap", (PyCFunction)Qt_GraphicsExportSetInputPixmap, 1, + PyDoc_STR("(GraphicsExportComponent ci, PixMapHandle pixmap) -> (ComponentResult _rv)")}, + {"GraphicsExportGetInputPixmap", (PyCFunction)Qt_GraphicsExportGetInputPixmap, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, PixMapHandle pixmap)")}, + {"GraphicsExportSetInputOffsetAndLimit", (PyCFunction)Qt_GraphicsExportSetInputOffsetAndLimit, 1, + PyDoc_STR("(GraphicsExportComponent ci, unsigned long offset, unsigned long limit) -> (ComponentResult _rv)")}, + {"GraphicsExportGetInputOffsetAndLimit", (PyCFunction)Qt_GraphicsExportGetInputOffsetAndLimit, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long offset, unsigned long limit)")}, + {"GraphicsExportMayExporterReadInputData", (PyCFunction)Qt_GraphicsExportMayExporterReadInputData, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean mayReadInputData)")}, + {"GraphicsExportGetInputDataSize", (PyCFunction)Qt_GraphicsExportGetInputDataSize, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long size)")}, + {"GraphicsExportReadInputData", (PyCFunction)Qt_GraphicsExportReadInputData, 1, + PyDoc_STR("(GraphicsExportComponent ci, void * dataPtr, unsigned long dataOffset, unsigned long dataSize) -> (ComponentResult _rv)")}, + {"GraphicsExportGetInputImageDescription", (PyCFunction)Qt_GraphicsExportGetInputImageDescription, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, ImageDescriptionHandle desc)")}, + {"GraphicsExportGetInputImageDimensions", (PyCFunction)Qt_GraphicsExportGetInputImageDimensions, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Rect dimensions)")}, + {"GraphicsExportGetInputImageDepth", (PyCFunction)Qt_GraphicsExportGetInputImageDepth, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, long inputDepth)")}, + {"GraphicsExportDrawInputImage", (PyCFunction)Qt_GraphicsExportDrawInputImage, 1, + PyDoc_STR("(GraphicsExportComponent ci, CGrafPtr gw, GDHandle gd, Rect srcRect, Rect dstRect) -> (ComponentResult _rv)")}, + {"GraphicsExportSetOutputDataReference", (PyCFunction)Qt_GraphicsExportSetOutputDataReference, 1, + PyDoc_STR("(GraphicsExportComponent ci, Handle dataRef, OSType dataRefType) -> (ComponentResult _rv)")}, + {"GraphicsExportGetOutputDataReference", (PyCFunction)Qt_GraphicsExportGetOutputDataReference, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType)")}, + {"GraphicsExportSetOutputFile", (PyCFunction)Qt_GraphicsExportSetOutputFile, 1, + PyDoc_STR("(GraphicsExportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")}, + {"GraphicsExportGetOutputFile", (PyCFunction)Qt_GraphicsExportGetOutputFile, 1, + PyDoc_STR("(GraphicsExportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")}, + {"GraphicsExportSetOutputHandle", (PyCFunction)Qt_GraphicsExportSetOutputHandle, 1, + PyDoc_STR("(GraphicsExportComponent ci, Handle h) -> (ComponentResult _rv)")}, + {"GraphicsExportGetOutputHandle", (PyCFunction)Qt_GraphicsExportGetOutputHandle, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle h)")}, + {"GraphicsExportSetOutputOffsetAndMaxSize", (PyCFunction)Qt_GraphicsExportSetOutputOffsetAndMaxSize, 1, + PyDoc_STR("(GraphicsExportComponent ci, unsigned long offset, unsigned long maxSize, Boolean truncateFile) -> (ComponentResult _rv)")}, + {"GraphicsExportGetOutputOffsetAndMaxSize", (PyCFunction)Qt_GraphicsExportGetOutputOffsetAndMaxSize, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long offset, unsigned long maxSize, Boolean truncateFile)")}, + {"GraphicsExportSetOutputFileTypeAndCreator", (PyCFunction)Qt_GraphicsExportSetOutputFileTypeAndCreator, 1, + PyDoc_STR("(GraphicsExportComponent ci, OSType fileType, OSType fileCreator) -> (ComponentResult _rv)")}, + {"GraphicsExportGetOutputFileTypeAndCreator", (PyCFunction)Qt_GraphicsExportGetOutputFileTypeAndCreator, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, OSType fileType, OSType fileCreator)")}, + {"GraphicsExportSetOutputMark", (PyCFunction)Qt_GraphicsExportSetOutputMark, 1, + PyDoc_STR("(GraphicsExportComponent ci, unsigned long mark) -> (ComponentResult _rv)")}, + {"GraphicsExportGetOutputMark", (PyCFunction)Qt_GraphicsExportGetOutputMark, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long mark)")}, + {"GraphicsExportReadOutputData", (PyCFunction)Qt_GraphicsExportReadOutputData, 1, + PyDoc_STR("(GraphicsExportComponent ci, void * dataPtr, unsigned long dataOffset, unsigned long dataSize) -> (ComponentResult _rv)")}, + {"GraphicsExportSetThumbnailEnabled", (PyCFunction)Qt_GraphicsExportSetThumbnailEnabled, 1, + PyDoc_STR("(GraphicsExportComponent ci, Boolean enableThumbnail, long maxThumbnailWidth, long maxThumbnailHeight) -> (ComponentResult _rv)")}, + {"GraphicsExportGetThumbnailEnabled", (PyCFunction)Qt_GraphicsExportGetThumbnailEnabled, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean thumbnailEnabled, long maxThumbnailWidth, long maxThumbnailHeight)")}, + {"GraphicsExportSetExifEnabled", (PyCFunction)Qt_GraphicsExportSetExifEnabled, 1, + PyDoc_STR("(GraphicsExportComponent ci, Boolean enableExif) -> (ComponentResult _rv)")}, + {"GraphicsExportGetExifEnabled", (PyCFunction)Qt_GraphicsExportGetExifEnabled, 1, + PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean exifEnabled)")}, + {"ImageTranscoderBeginSequence", (PyCFunction)Qt_ImageTranscoderBeginSequence, 1, + PyDoc_STR("(ImageTranscoderComponent itc, ImageDescriptionHandle srcDesc, void * data, long dataSize) -> (ComponentResult _rv, ImageDescriptionHandle dstDesc)")}, + {"ImageTranscoderDisposeData", (PyCFunction)Qt_ImageTranscoderDisposeData, 1, + PyDoc_STR("(ImageTranscoderComponent itc, void * dstData) -> (ComponentResult _rv)")}, + {"ImageTranscoderEndSequence", (PyCFunction)Qt_ImageTranscoderEndSequence, 1, + PyDoc_STR("(ImageTranscoderComponent itc) -> (ComponentResult _rv)")}, {"AlignWindow", (PyCFunction)Qt_AlignWindow, 1, PyDoc_STR("(WindowPtr wp, Boolean front) -> None")}, {"DragAlignedWindow", (PyCFunction)Qt_DragAlignedWindow, 1, diff --git a/Mac/Modules/qt/qtscan.py b/Mac/Modules/qt/qtscan.py index eca1f23..05b4206 100644 --- a/Mac/Modules/qt/qtscan.py +++ b/Mac/Modules/qt/qtscan.py @@ -11,7 +11,7 @@ SHORT = "qt" OBJECTS = ("Movie", "Track", "Media", "UserData", "TimeBase", "MovieController", "IdleManager") def main(): - input = "Movies.h" + input = ("Movies.h", "ImageCompression.h") output = SHORT + "gen.py" defsoutput = TOOLBOXDIR + LONG + ".py" scanner = MyScanner(input, output, defsoutput) @@ -76,6 +76,8 @@ class MyScanner(Scanner): 'MovieMediaLoadChildMovieFromDataReference', 'Media3DGetViewObject', + # these are ImageCompression blacklists + "GraphicsExportGetInputPtr", ] def makeblacklisttypes(self): @@ -122,6 +124,38 @@ class MyScanner(Scanner): "QTAtomContainer", "SpriteWorld", "Sprite", + + # these are ImageCompression blacklists + "ICMDataUPP", + "ICMFlushUPP", + "ICMCompletionUPP", + "ICMProgressUPP", + "StdPixUPP", + "QDPixUPP", + "ICMAlignmentUPP", + "ICMCursorShieldedUPP", + "ICMMemoryDisposedUPP", + "ICMConvertDataFormatUPP", + "ModalFilterYDUPP", + "FileFilterUPP", + + "CodecNameSpecListPtr", + "CodecInfo", + "ImageSequence", + "MatrixRecordPtr", + "ICMDataProcRecordPtr", + "OpenCPicParams", + "ICMProgressProcRecordPtr", + "ICMAlignmentProcRecordPtr", + "ICMPixelFormatInfoPtr", + "ImageSequenceDataSource", + "ConstStrFileNameParam", + "ImageTranscodeSequence", + "ImageFieldSequence", + "Fract", + "PixMapPtr", + "GWorldFlags", + "void_ptr", # XXX Being lazy, this one is doable. ] def makerepairinstructions(self): diff --git a/Mac/Modules/qt/qtsupport.py b/Mac/Modules/qt/qtsupport.py index 4eb906e..bb37380 100644 --- a/Mac/Modules/qt/qtsupport.py +++ b/Mac/Modules/qt/qtsupport.py @@ -121,6 +121,13 @@ IdleManager = OpaqueByValueType('IdleManager', 'IdleManagerObj') Component = OpaqueByValueType('Component', 'CmpObj') MediaHandlerComponent = OpaqueByValueType('MediaHandlerComponent', 'CmpObj') DataHandlerComponent = OpaqueByValueType('DataHandlerComponent', 'CmpObj') +CompressorComponent = OpaqueByValueType('CompressorComponent', 'CmpObj') +DecompressorComponent = OpaqueByValueType('DecompressorComponent', 'CmpObj') +CodecComponent = OpaqueByValueType('CodecComponent', 'CmpObj') +GraphicsImportComponent = OpaqueByValueType('GraphicsImportComponent', 'CmpObj') +GraphicsExportComponent = OpaqueByValueType('GraphicsExportComponent', 'CmpObj') +ImageTranscoderComponent = OpaqueByValueType('ImageTranscoderComponent', 'CmpObj') + ComponentInstance = OpaqueByValueType('ComponentInstance', 'CmpInstObj') MediaHandler = OpaqueByValueType('MediaHandler', 'CmpInstObj') @@ -172,6 +179,7 @@ MCInterfaceElement = Type("MCInterfaceElement", "l") CodecType = OSTypeType("CodecType") GWorldPtr = OpaqueByValueType("GWorldPtr", "GWorldObj") QTFloatSingle = Type("QTFloatSingle", "f") +CodecQ = Type("CodecQ", "l") # Could-not-be-bothered-types (NewMovieFromFile) dummyshortptr = FakeType('(short *)0') |