diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/icn/_Icnmodule.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/icn/_Icnmodule.c Fri Jul 31 15:01:17 2009 +0100 @@ -0,0 +1,1607 @@ + +/* ========================== Module _Icn =========================== */ + +#include "Python.h" + + +#ifndef __LP64__ + +#include "pymactoolbox.h" + +/* Macro to test whether a weak-loaded CFM function exists */ +#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ + PyErr_SetString(PyExc_NotImplementedError, \ + "Not available in this shared library/OS version"); \ + return NULL; \ + }} while(0) + + +#include + + +static PyObject *Icn_Error; + +static PyObject *Icn_GetCIcon(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CIconHandle _rv; + SInt16 iconID; +#ifndef GetCIcon + PyMac_PRECHECK(GetCIcon); +#endif + if (!PyArg_ParseTuple(_args, "h", + &iconID)) + return NULL; + _rv = GetCIcon(iconID); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *Icn_PlotCIcon(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Rect theRect; + CIconHandle theIcon; +#ifndef PlotCIcon + PyMac_PRECHECK(PlotCIcon); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetRect, &theRect, + ResObj_Convert, &theIcon)) + return NULL; + PlotCIcon(&theRect, + theIcon); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_DisposeCIcon(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CIconHandle theIcon; +#ifndef DisposeCIcon + PyMac_PRECHECK(DisposeCIcon); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &theIcon)) + return NULL; + DisposeCIcon(theIcon); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_GetIcon(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Handle _rv; + SInt16 iconID; +#ifndef GetIcon + PyMac_PRECHECK(GetIcon); +#endif + if (!PyArg_ParseTuple(_args, "h", + &iconID)) + return NULL; + _rv = GetIcon(iconID); + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *Icn_PlotIcon(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Rect theRect; + Handle theIcon; +#ifndef PlotIcon + PyMac_PRECHECK(PlotIcon); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetRect, &theRect, + ResObj_Convert, &theIcon)) + return NULL; + PlotIcon(&theRect, + theIcon); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_PlotIconID(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Rect theRect; + IconAlignmentType align; + IconTransformType transform; + SInt16 theResID; +#ifndef PlotIconID + PyMac_PRECHECK(PlotIconID); +#endif + if (!PyArg_ParseTuple(_args, "O&hhh", + PyMac_GetRect, &theRect, + &align, + &transform, + &theResID)) + return NULL; + _err = PlotIconID(&theRect, + align, + transform, + theResID); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_NewIconSuite(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconSuiteRef theIconSuite; +#ifndef NewIconSuite + PyMac_PRECHECK(NewIconSuite); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = NewIconSuite(&theIconSuite); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, theIconSuite); + return _res; +} + +static PyObject *Icn_AddIconToSuite(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Handle theIconData; + IconSuiteRef theSuite; + ResType theType; +#ifndef AddIconToSuite + PyMac_PRECHECK(AddIconToSuite); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + ResObj_Convert, &theIconData, + ResObj_Convert, &theSuite, + PyMac_GetOSType, &theType)) + return NULL; + _err = AddIconToSuite(theIconData, + theSuite, + theType); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_GetIconFromSuite(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Handle theIconData; + IconSuiteRef theSuite; + ResType theType; +#ifndef GetIconFromSuite + PyMac_PRECHECK(GetIconFromSuite); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + ResObj_Convert, &theSuite, + PyMac_GetOSType, &theType)) + return NULL; + _err = GetIconFromSuite(&theIconData, + theSuite, + theType); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, theIconData); + return _res; +} + +static PyObject *Icn_GetIconSuite(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconSuiteRef theIconSuite; + SInt16 theResID; + IconSelectorValue selector; +#ifndef GetIconSuite + PyMac_PRECHECK(GetIconSuite); +#endif + if (!PyArg_ParseTuple(_args, "hl", + &theResID, + &selector)) + return NULL; + _err = GetIconSuite(&theIconSuite, + theResID, + selector); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, theIconSuite); + return _res; +} + +static PyObject *Icn_DisposeIconSuite(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconSuiteRef theIconSuite; + Boolean disposeData; +#ifndef DisposeIconSuite + PyMac_PRECHECK(DisposeIconSuite); +#endif + if (!PyArg_ParseTuple(_args, "O&b", + ResObj_Convert, &theIconSuite, + &disposeData)) + return NULL; + _err = DisposeIconSuite(theIconSuite, + disposeData); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_PlotIconSuite(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Rect theRect; + IconAlignmentType align; + IconTransformType transform; + IconSuiteRef theIconSuite; +#ifndef PlotIconSuite + PyMac_PRECHECK(PlotIconSuite); +#endif + if (!PyArg_ParseTuple(_args, "O&hhO&", + PyMac_GetRect, &theRect, + &align, + &transform, + ResObj_Convert, &theIconSuite)) + return NULL; + _err = PlotIconSuite(&theRect, + align, + transform, + theIconSuite); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_LoadIconCache(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Rect theRect; + IconAlignmentType align; + IconTransformType transform; + IconCacheRef theIconCache; +#ifndef LoadIconCache + PyMac_PRECHECK(LoadIconCache); +#endif + if (!PyArg_ParseTuple(_args, "O&hhO&", + PyMac_GetRect, &theRect, + &align, + &transform, + ResObj_Convert, &theIconCache)) + return NULL; + _err = LoadIconCache(&theRect, + align, + transform, + theIconCache); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_GetLabel(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 labelNumber; + RGBColor labelColor; + Str255 labelString; +#ifndef GetLabel + PyMac_PRECHECK(GetLabel); +#endif + if (!PyArg_ParseTuple(_args, "hO&", + &labelNumber, + PyMac_GetStr255, labelString)) + return NULL; + _err = GetLabel(labelNumber, + &labelColor, + labelString); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + QdRGB_New, &labelColor); + return _res; +} + +static PyObject *Icn_PtInIconID(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + Point testPt; + Rect iconRect; + IconAlignmentType align; + SInt16 iconID; +#ifndef PtInIconID + PyMac_PRECHECK(PtInIconID); +#endif + if (!PyArg_ParseTuple(_args, "O&O&hh", + PyMac_GetPoint, &testPt, + PyMac_GetRect, &iconRect, + &align, + &iconID)) + return NULL; + _rv = PtInIconID(testPt, + &iconRect, + align, + iconID); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *Icn_PtInIconSuite(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + Point testPt; + Rect iconRect; + IconAlignmentType align; + IconSuiteRef theIconSuite; +#ifndef PtInIconSuite + PyMac_PRECHECK(PtInIconSuite); +#endif + if (!PyArg_ParseTuple(_args, "O&O&hO&", + PyMac_GetPoint, &testPt, + PyMac_GetRect, &iconRect, + &align, + ResObj_Convert, &theIconSuite)) + return NULL; + _rv = PtInIconSuite(testPt, + &iconRect, + align, + theIconSuite); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *Icn_RectInIconID(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + Rect testRect; + Rect iconRect; + IconAlignmentType align; + SInt16 iconID; +#ifndef RectInIconID + PyMac_PRECHECK(RectInIconID); +#endif + if (!PyArg_ParseTuple(_args, "O&O&hh", + PyMac_GetRect, &testRect, + PyMac_GetRect, &iconRect, + &align, + &iconID)) + return NULL; + _rv = RectInIconID(&testRect, + &iconRect, + align, + iconID); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *Icn_RectInIconSuite(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + Rect testRect; + Rect iconRect; + IconAlignmentType align; + IconSuiteRef theIconSuite; +#ifndef RectInIconSuite + PyMac_PRECHECK(RectInIconSuite); +#endif + if (!PyArg_ParseTuple(_args, "O&O&hO&", + PyMac_GetRect, &testRect, + PyMac_GetRect, &iconRect, + &align, + ResObj_Convert, &theIconSuite)) + return NULL; + _rv = RectInIconSuite(&testRect, + &iconRect, + align, + theIconSuite); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *Icn_IconIDToRgn(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + RgnHandle theRgn; + Rect iconRect; + IconAlignmentType align; + SInt16 iconID; +#ifndef IconIDToRgn + PyMac_PRECHECK(IconIDToRgn); +#endif + if (!PyArg_ParseTuple(_args, "O&O&hh", + ResObj_Convert, &theRgn, + PyMac_GetRect, &iconRect, + &align, + &iconID)) + return NULL; + _err = IconIDToRgn(theRgn, + &iconRect, + align, + iconID); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_IconSuiteToRgn(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + RgnHandle theRgn; + Rect iconRect; + IconAlignmentType align; + IconSuiteRef theIconSuite; +#ifndef IconSuiteToRgn + PyMac_PRECHECK(IconSuiteToRgn); +#endif + if (!PyArg_ParseTuple(_args, "O&O&hO&", + ResObj_Convert, &theRgn, + PyMac_GetRect, &iconRect, + &align, + ResObj_Convert, &theIconSuite)) + return NULL; + _err = IconSuiteToRgn(theRgn, + &iconRect, + align, + theIconSuite); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_SetSuiteLabel(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconSuiteRef theSuite; + SInt16 theLabel; +#ifndef SetSuiteLabel + PyMac_PRECHECK(SetSuiteLabel); +#endif + if (!PyArg_ParseTuple(_args, "O&h", + ResObj_Convert, &theSuite, + &theLabel)) + return NULL; + _err = SetSuiteLabel(theSuite, + theLabel); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_GetSuiteLabel(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + SInt16 _rv; + IconSuiteRef theSuite; +#ifndef GetSuiteLabel + PyMac_PRECHECK(GetSuiteLabel); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &theSuite)) + return NULL; + _rv = GetSuiteLabel(theSuite); + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *Icn_PlotIconHandle(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Rect theRect; + IconAlignmentType align; + IconTransformType transform; + Handle theIcon; +#ifndef PlotIconHandle + PyMac_PRECHECK(PlotIconHandle); +#endif + if (!PyArg_ParseTuple(_args, "O&hhO&", + PyMac_GetRect, &theRect, + &align, + &transform, + ResObj_Convert, &theIcon)) + return NULL; + _err = PlotIconHandle(&theRect, + align, + transform, + theIcon); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_PlotSICNHandle(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Rect theRect; + IconAlignmentType align; + IconTransformType transform; + Handle theSICN; +#ifndef PlotSICNHandle + PyMac_PRECHECK(PlotSICNHandle); +#endif + if (!PyArg_ParseTuple(_args, "O&hhO&", + PyMac_GetRect, &theRect, + &align, + &transform, + ResObj_Convert, &theSICN)) + return NULL; + _err = PlotSICNHandle(&theRect, + align, + transform, + theSICN); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_PlotCIconHandle(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Rect theRect; + IconAlignmentType align; + IconTransformType transform; + CIconHandle theCIcon; +#ifndef PlotCIconHandle + PyMac_PRECHECK(PlotCIconHandle); +#endif + if (!PyArg_ParseTuple(_args, "O&hhO&", + PyMac_GetRect, &theRect, + &align, + &transform, + ResObj_Convert, &theCIcon)) + return NULL; + _err = PlotCIconHandle(&theRect, + align, + transform, + theCIcon); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_IconRefToIconFamily(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconRef theIconRef; + IconSelectorValue whichIcons; + IconFamilyHandle iconFamily; +#ifndef IconRefToIconFamily + PyMac_PRECHECK(IconRefToIconFamily); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + ResObj_Convert, &theIconRef, + &whichIcons)) + return NULL; + _err = IconRefToIconFamily(theIconRef, + whichIcons, + &iconFamily); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, iconFamily); + return _res; +} + +static PyObject *Icn_IconFamilyToIconSuite(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconFamilyHandle iconFamily; + IconSelectorValue whichIcons; + IconSuiteRef iconSuite; +#ifndef IconFamilyToIconSuite + PyMac_PRECHECK(IconFamilyToIconSuite); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + ResObj_Convert, &iconFamily, + &whichIcons)) + return NULL; + _err = IconFamilyToIconSuite(iconFamily, + whichIcons, + &iconSuite); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, iconSuite); + return _res; +} + +static PyObject *Icn_IconSuiteToIconFamily(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconSuiteRef iconSuite; + IconSelectorValue whichIcons; + IconFamilyHandle iconFamily; +#ifndef IconSuiteToIconFamily + PyMac_PRECHECK(IconSuiteToIconFamily); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + ResObj_Convert, &iconSuite, + &whichIcons)) + return NULL; + _err = IconSuiteToIconFamily(iconSuite, + whichIcons, + &iconFamily); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, iconFamily); + return _res; +} + +static PyObject *Icn_SetIconFamilyData(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconFamilyHandle iconFamily; + OSType iconType; + Handle h; +#ifndef SetIconFamilyData + PyMac_PRECHECK(SetIconFamilyData); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + ResObj_Convert, &iconFamily, + PyMac_GetOSType, &iconType, + ResObj_Convert, &h)) + return NULL; + _err = SetIconFamilyData(iconFamily, + iconType, + h); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_GetIconFamilyData(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconFamilyHandle iconFamily; + OSType iconType; + Handle h; +#ifndef GetIconFamilyData + PyMac_PRECHECK(GetIconFamilyData); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + ResObj_Convert, &iconFamily, + PyMac_GetOSType, &iconType, + ResObj_Convert, &h)) + return NULL; + _err = GetIconFamilyData(iconFamily, + iconType, + h); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_GetIconRefOwners(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconRef theIconRef; + UInt16 owners; +#ifndef GetIconRefOwners + PyMac_PRECHECK(GetIconRefOwners); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &theIconRef)) + return NULL; + _err = GetIconRefOwners(theIconRef, + &owners); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("H", + owners); + return _res; +} + +static PyObject *Icn_AcquireIconRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconRef theIconRef; +#ifndef AcquireIconRef + PyMac_PRECHECK(AcquireIconRef); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &theIconRef)) + return NULL; + _err = AcquireIconRef(theIconRef); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_ReleaseIconRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconRef theIconRef; +#ifndef ReleaseIconRef + PyMac_PRECHECK(ReleaseIconRef); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &theIconRef)) + return NULL; + _err = ReleaseIconRef(theIconRef); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_GetIconRefFromFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec theFile; + IconRef theIconRef; + SInt16 theLabel; +#ifndef GetIconRefFromFile + PyMac_PRECHECK(GetIconRefFromFile); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSSpec, &theFile)) + return NULL; + _err = GetIconRefFromFile(&theFile, + &theIconRef, + &theLabel); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&h", + ResObj_New, theIconRef, + theLabel); + return _res; +} + +static PyObject *Icn_GetIconRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 vRefNum; + OSType creator; + OSType iconType; + IconRef theIconRef; +#ifndef GetIconRef + PyMac_PRECHECK(GetIconRef); +#endif + if (!PyArg_ParseTuple(_args, "hO&O&", + &vRefNum, + PyMac_GetOSType, &creator, + PyMac_GetOSType, &iconType)) + return NULL; + _err = GetIconRef(vRefNum, + creator, + iconType, + &theIconRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, theIconRef); + return _res; +} + +static PyObject *Icn_GetIconRefFromFolder(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 vRefNum; + SInt32 parentFolderID; + SInt32 folderID; + SInt8 attributes; + SInt8 accessPrivileges; + IconRef theIconRef; +#ifndef GetIconRefFromFolder + PyMac_PRECHECK(GetIconRefFromFolder); +#endif + if (!PyArg_ParseTuple(_args, "hllbb", + &vRefNum, + &parentFolderID, + &folderID, + &attributes, + &accessPrivileges)) + return NULL; + _err = GetIconRefFromFolder(vRefNum, + parentFolderID, + folderID, + attributes, + accessPrivileges, + &theIconRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, theIconRef); + return _res; +} + +static PyObject *Icn_RegisterIconRefFromIconFamily(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + OSType creator; + OSType iconType; + IconFamilyHandle iconFamily; + IconRef theIconRef; +#ifndef RegisterIconRefFromIconFamily + PyMac_PRECHECK(RegisterIconRefFromIconFamily); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + PyMac_GetOSType, &creator, + PyMac_GetOSType, &iconType, + ResObj_Convert, &iconFamily)) + return NULL; + _err = RegisterIconRefFromIconFamily(creator, + iconType, + iconFamily, + &theIconRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, theIconRef); + return _res; +} + +static PyObject *Icn_RegisterIconRefFromResource(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + OSType creator; + OSType iconType; + FSSpec resourceFile; + SInt16 resourceID; + IconRef theIconRef; +#ifndef RegisterIconRefFromResource + PyMac_PRECHECK(RegisterIconRefFromResource); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&h", + PyMac_GetOSType, &creator, + PyMac_GetOSType, &iconType, + PyMac_GetFSSpec, &resourceFile, + &resourceID)) + return NULL; + _err = RegisterIconRefFromResource(creator, + iconType, + &resourceFile, + resourceID, + &theIconRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, theIconRef); + return _res; +} + +static PyObject *Icn_RegisterIconRefFromFSRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + OSType creator; + OSType iconType; + FSRef iconFile; + IconRef theIconRef; +#ifndef RegisterIconRefFromFSRef + PyMac_PRECHECK(RegisterIconRefFromFSRef); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + PyMac_GetOSType, &creator, + PyMac_GetOSType, &iconType, + PyMac_GetFSRef, &iconFile)) + return NULL; + _err = RegisterIconRefFromFSRef(creator, + iconType, + &iconFile, + &theIconRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, theIconRef); + return _res; +} + +static PyObject *Icn_UnregisterIconRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + OSType creator; + OSType iconType; +#ifndef UnregisterIconRef + PyMac_PRECHECK(UnregisterIconRef); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetOSType, &creator, + PyMac_GetOSType, &iconType)) + return NULL; + _err = UnregisterIconRef(creator, + iconType); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_UpdateIconRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconRef theIconRef; +#ifndef UpdateIconRef + PyMac_PRECHECK(UpdateIconRef); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &theIconRef)) + return NULL; + _err = UpdateIconRef(theIconRef); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_OverrideIconRefFromResource(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconRef theIconRef; + FSSpec resourceFile; + SInt16 resourceID; +#ifndef OverrideIconRefFromResource + PyMac_PRECHECK(OverrideIconRefFromResource); +#endif + if (!PyArg_ParseTuple(_args, "O&O&h", + ResObj_Convert, &theIconRef, + PyMac_GetFSSpec, &resourceFile, + &resourceID)) + return NULL; + _err = OverrideIconRefFromResource(theIconRef, + &resourceFile, + resourceID); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_OverrideIconRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconRef oldIconRef; + IconRef newIconRef; +#ifndef OverrideIconRef + PyMac_PRECHECK(OverrideIconRef); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + ResObj_Convert, &oldIconRef, + ResObj_Convert, &newIconRef)) + return NULL; + _err = OverrideIconRef(oldIconRef, + newIconRef); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_RemoveIconRefOverride(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconRef theIconRef; +#ifndef RemoveIconRefOverride + PyMac_PRECHECK(RemoveIconRefOverride); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &theIconRef)) + return NULL; + _err = RemoveIconRefOverride(theIconRef); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_CompositeIconRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconRef backgroundIconRef; + IconRef foregroundIconRef; + IconRef compositeIconRef; +#ifndef CompositeIconRef + PyMac_PRECHECK(CompositeIconRef); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + ResObj_Convert, &backgroundIconRef, + ResObj_Convert, &foregroundIconRef)) + return NULL; + _err = CompositeIconRef(backgroundIconRef, + foregroundIconRef, + &compositeIconRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, compositeIconRef); + return _res; +} + +static PyObject *Icn_IsIconRefComposite(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconRef compositeIconRef; + IconRef backgroundIconRef; + IconRef foregroundIconRef; +#ifndef IsIconRefComposite + PyMac_PRECHECK(IsIconRefComposite); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &compositeIconRef)) + return NULL; + _err = IsIconRefComposite(compositeIconRef, + &backgroundIconRef, + &foregroundIconRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&O&", + ResObj_New, backgroundIconRef, + ResObj_New, foregroundIconRef); + return _res; +} + +static PyObject *Icn_IsValidIconRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + IconRef theIconRef; +#ifndef IsValidIconRef + PyMac_PRECHECK(IsValidIconRef); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &theIconRef)) + return NULL; + _rv = IsValidIconRef(theIconRef); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *Icn_PlotIconRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Rect theRect; + IconAlignmentType align; + IconTransformType transform; + IconServicesUsageFlags theIconServicesUsageFlags; + IconRef theIconRef; +#ifndef PlotIconRef + PyMac_PRECHECK(PlotIconRef); +#endif + if (!PyArg_ParseTuple(_args, "O&hhlO&", + PyMac_GetRect, &theRect, + &align, + &transform, + &theIconServicesUsageFlags, + ResObj_Convert, &theIconRef)) + return NULL; + _err = PlotIconRef(&theRect, + align, + transform, + theIconServicesUsageFlags, + theIconRef); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_PtInIconRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + Point testPt; + Rect iconRect; + IconAlignmentType align; + IconServicesUsageFlags theIconServicesUsageFlags; + IconRef theIconRef; +#ifndef PtInIconRef + PyMac_PRECHECK(PtInIconRef); +#endif + if (!PyArg_ParseTuple(_args, "O&O&hlO&", + PyMac_GetPoint, &testPt, + PyMac_GetRect, &iconRect, + &align, + &theIconServicesUsageFlags, + ResObj_Convert, &theIconRef)) + return NULL; + _rv = PtInIconRef(&testPt, + &iconRect, + align, + theIconServicesUsageFlags, + theIconRef); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *Icn_RectInIconRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + Rect testRect; + Rect iconRect; + IconAlignmentType align; + IconServicesUsageFlags iconServicesUsageFlags; + IconRef theIconRef; +#ifndef RectInIconRef + PyMac_PRECHECK(RectInIconRef); +#endif + if (!PyArg_ParseTuple(_args, "O&O&hlO&", + PyMac_GetRect, &testRect, + PyMac_GetRect, &iconRect, + &align, + &iconServicesUsageFlags, + ResObj_Convert, &theIconRef)) + return NULL; + _rv = RectInIconRef(&testRect, + &iconRect, + align, + iconServicesUsageFlags, + theIconRef); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *Icn_IconRefToRgn(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + RgnHandle theRgn; + Rect iconRect; + IconAlignmentType align; + IconServicesUsageFlags iconServicesUsageFlags; + IconRef theIconRef; +#ifndef IconRefToRgn + PyMac_PRECHECK(IconRefToRgn); +#endif + if (!PyArg_ParseTuple(_args, "O&O&hlO&", + ResObj_Convert, &theRgn, + PyMac_GetRect, &iconRect, + &align, + &iconServicesUsageFlags, + ResObj_Convert, &theIconRef)) + return NULL; + _err = IconRefToRgn(theRgn, + &iconRect, + align, + iconServicesUsageFlags, + theIconRef); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_GetIconSizesFromIconRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconSelectorValue iconSelectorInput; + IconSelectorValue iconSelectorOutputPtr; + IconServicesUsageFlags iconServicesUsageFlags; + IconRef theIconRef; +#ifndef GetIconSizesFromIconRef + PyMac_PRECHECK(GetIconSizesFromIconRef); +#endif + if (!PyArg_ParseTuple(_args, "llO&", + &iconSelectorInput, + &iconServicesUsageFlags, + ResObj_Convert, &theIconRef)) + return NULL; + _err = GetIconSizesFromIconRef(iconSelectorInput, + &iconSelectorOutputPtr, + iconServicesUsageFlags, + theIconRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + iconSelectorOutputPtr); + return _res; +} + +static PyObject *Icn_FlushIconRefs(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + OSType creator; + OSType iconType; +#ifndef FlushIconRefs + PyMac_PRECHECK(FlushIconRefs); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetOSType, &creator, + PyMac_GetOSType, &iconType)) + return NULL; + _err = FlushIconRefs(creator, + iconType); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_FlushIconRefsByVolume(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 vRefNum; +#ifndef FlushIconRefsByVolume + PyMac_PRECHECK(FlushIconRefsByVolume); +#endif + if (!PyArg_ParseTuple(_args, "h", + &vRefNum)) + return NULL; + _err = FlushIconRefsByVolume(vRefNum); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_SetCustomIconsEnabled(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 vRefNum; + Boolean enableCustomIcons; +#ifndef SetCustomIconsEnabled + PyMac_PRECHECK(SetCustomIconsEnabled); +#endif + if (!PyArg_ParseTuple(_args, "hb", + &vRefNum, + &enableCustomIcons)) + return NULL; + _err = SetCustomIconsEnabled(vRefNum, + enableCustomIcons); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Icn_GetCustomIconsEnabled(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 vRefNum; + Boolean customIconsEnabled; +#ifndef GetCustomIconsEnabled + PyMac_PRECHECK(GetCustomIconsEnabled); +#endif + if (!PyArg_ParseTuple(_args, "h", + &vRefNum)) + return NULL; + _err = GetCustomIconsEnabled(vRefNum, + &customIconsEnabled); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("b", + customIconsEnabled); + return _res; +} + +static PyObject *Icn_IsIconRefMaskEmpty(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + IconRef iconRef; +#ifndef IsIconRefMaskEmpty + PyMac_PRECHECK(IsIconRefMaskEmpty); +#endif + if (!PyArg_ParseTuple(_args, "O&", + ResObj_Convert, &iconRef)) + return NULL; + _rv = IsIconRefMaskEmpty(iconRef); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *Icn_GetIconRefVariant(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + IconRef _rv; + IconRef inIconRef; + OSType inVariant; + IconTransformType outTransform; +#ifndef GetIconRefVariant + PyMac_PRECHECK(GetIconRefVariant); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + ResObj_Convert, &inIconRef, + PyMac_GetOSType, &inVariant)) + return NULL; + _rv = GetIconRefVariant(inIconRef, + inVariant, + &outTransform); + _res = Py_BuildValue("O&h", + ResObj_New, _rv, + outTransform); + return _res; +} + +static PyObject *Icn_RegisterIconRefFromIconFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + OSType creator; + OSType iconType; + FSSpec iconFile; + IconRef theIconRef; +#ifndef RegisterIconRefFromIconFile + PyMac_PRECHECK(RegisterIconRefFromIconFile); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + PyMac_GetOSType, &creator, + PyMac_GetOSType, &iconType, + PyMac_GetFSSpec, &iconFile)) + return NULL; + _err = RegisterIconRefFromIconFile(creator, + iconType, + &iconFile, + &theIconRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, theIconRef); + return _res; +} + +static PyObject *Icn_ReadIconFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec iconFile; + IconFamilyHandle iconFamily; +#ifndef ReadIconFile + PyMac_PRECHECK(ReadIconFile); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSSpec, &iconFile)) + return NULL; + _err = ReadIconFile(&iconFile, + &iconFamily); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, iconFamily); + return _res; +} + +static PyObject *Icn_ReadIconFromFSRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + FSRef ref; + IconFamilyHandle iconFamily; +#ifndef ReadIconFromFSRef + PyMac_PRECHECK(ReadIconFromFSRef); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSRef, &ref)) + return NULL; + _err = ReadIconFromFSRef(&ref, + &iconFamily); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + ResObj_New, iconFamily); + return _res; +} + +static PyObject *Icn_WriteIconFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + IconFamilyHandle iconFamily; + FSSpec iconFile; +#ifndef WriteIconFile + PyMac_PRECHECK(WriteIconFile); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + ResObj_Convert, &iconFamily, + PyMac_GetFSSpec, &iconFile)) + return NULL; + _err = WriteIconFile(iconFamily, + &iconFile); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif /* __LP64__ */ + +static PyMethodDef Icn_methods[] = { +#ifndef __LP64__ + {"GetCIcon", (PyCFunction)Icn_GetCIcon, 1, + PyDoc_STR("(SInt16 iconID) -> (CIconHandle _rv)")}, + {"PlotCIcon", (PyCFunction)Icn_PlotCIcon, 1, + PyDoc_STR("(Rect theRect, CIconHandle theIcon) -> None")}, + {"DisposeCIcon", (PyCFunction)Icn_DisposeCIcon, 1, + PyDoc_STR("(CIconHandle theIcon) -> None")}, + {"GetIcon", (PyCFunction)Icn_GetIcon, 1, + PyDoc_STR("(SInt16 iconID) -> (Handle _rv)")}, + {"PlotIcon", (PyCFunction)Icn_PlotIcon, 1, + PyDoc_STR("(Rect theRect, Handle theIcon) -> None")}, + {"PlotIconID", (PyCFunction)Icn_PlotIconID, 1, + PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, SInt16 theResID) -> None")}, + {"NewIconSuite", (PyCFunction)Icn_NewIconSuite, 1, + PyDoc_STR("() -> (IconSuiteRef theIconSuite)")}, + {"AddIconToSuite", (PyCFunction)Icn_AddIconToSuite, 1, + PyDoc_STR("(Handle theIconData, IconSuiteRef theSuite, ResType theType) -> None")}, + {"GetIconFromSuite", (PyCFunction)Icn_GetIconFromSuite, 1, + PyDoc_STR("(IconSuiteRef theSuite, ResType theType) -> (Handle theIconData)")}, + {"GetIconSuite", (PyCFunction)Icn_GetIconSuite, 1, + PyDoc_STR("(SInt16 theResID, IconSelectorValue selector) -> (IconSuiteRef theIconSuite)")}, + {"DisposeIconSuite", (PyCFunction)Icn_DisposeIconSuite, 1, + PyDoc_STR("(IconSuiteRef theIconSuite, Boolean disposeData) -> None")}, + {"PlotIconSuite", (PyCFunction)Icn_PlotIconSuite, 1, + PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconSuiteRef theIconSuite) -> None")}, + {"LoadIconCache", (PyCFunction)Icn_LoadIconCache, 1, + PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconCacheRef theIconCache) -> None")}, + {"GetLabel", (PyCFunction)Icn_GetLabel, 1, + PyDoc_STR("(SInt16 labelNumber, Str255 labelString) -> (RGBColor labelColor)")}, + {"PtInIconID", (PyCFunction)Icn_PtInIconID, 1, + PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)")}, + {"PtInIconSuite", (PyCFunction)Icn_PtInIconSuite, 1, + PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)")}, + {"RectInIconID", (PyCFunction)Icn_RectInIconID, 1, + PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)")}, + {"RectInIconSuite", (PyCFunction)Icn_RectInIconSuite, 1, + PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)")}, + {"IconIDToRgn", (PyCFunction)Icn_IconIDToRgn, 1, + PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> None")}, + {"IconSuiteToRgn", (PyCFunction)Icn_IconSuiteToRgn, 1, + PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> None")}, + {"SetSuiteLabel", (PyCFunction)Icn_SetSuiteLabel, 1, + PyDoc_STR("(IconSuiteRef theSuite, SInt16 theLabel) -> None")}, + {"GetSuiteLabel", (PyCFunction)Icn_GetSuiteLabel, 1, + PyDoc_STR("(IconSuiteRef theSuite) -> (SInt16 _rv)")}, + {"PlotIconHandle", (PyCFunction)Icn_PlotIconHandle, 1, + PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theIcon) -> None")}, + {"PlotSICNHandle", (PyCFunction)Icn_PlotSICNHandle, 1, + PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theSICN) -> None")}, + {"PlotCIconHandle", (PyCFunction)Icn_PlotCIconHandle, 1, + PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, CIconHandle theCIcon) -> None")}, + {"IconRefToIconFamily", (PyCFunction)Icn_IconRefToIconFamily, 1, + PyDoc_STR("(IconRef theIconRef, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)")}, + {"IconFamilyToIconSuite", (PyCFunction)Icn_IconFamilyToIconSuite, 1, + PyDoc_STR("(IconFamilyHandle iconFamily, IconSelectorValue whichIcons) -> (IconSuiteRef iconSuite)")}, + {"IconSuiteToIconFamily", (PyCFunction)Icn_IconSuiteToIconFamily, 1, + PyDoc_STR("(IconSuiteRef iconSuite, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)")}, + {"SetIconFamilyData", (PyCFunction)Icn_SetIconFamilyData, 1, + PyDoc_STR("(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None")}, + {"GetIconFamilyData", (PyCFunction)Icn_GetIconFamilyData, 1, + PyDoc_STR("(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None")}, + {"GetIconRefOwners", (PyCFunction)Icn_GetIconRefOwners, 1, + PyDoc_STR("(IconRef theIconRef) -> (UInt16 owners)")}, + {"AcquireIconRef", (PyCFunction)Icn_AcquireIconRef, 1, + PyDoc_STR("(IconRef theIconRef) -> None")}, + {"ReleaseIconRef", (PyCFunction)Icn_ReleaseIconRef, 1, + PyDoc_STR("(IconRef theIconRef) -> None")}, + {"GetIconRefFromFile", (PyCFunction)Icn_GetIconRefFromFile, 1, + PyDoc_STR("(FSSpec theFile) -> (IconRef theIconRef, SInt16 theLabel)")}, + {"GetIconRef", (PyCFunction)Icn_GetIconRef, 1, + PyDoc_STR("(SInt16 vRefNum, OSType creator, OSType iconType) -> (IconRef theIconRef)")}, + {"GetIconRefFromFolder", (PyCFunction)Icn_GetIconRefFromFolder, 1, + PyDoc_STR("(SInt16 vRefNum, SInt32 parentFolderID, SInt32 folderID, SInt8 attributes, SInt8 accessPrivileges) -> (IconRef theIconRef)")}, + {"RegisterIconRefFromIconFamily", (PyCFunction)Icn_RegisterIconRefFromIconFamily, 1, + PyDoc_STR("(OSType creator, OSType iconType, IconFamilyHandle iconFamily) -> (IconRef theIconRef)")}, + {"RegisterIconRefFromResource", (PyCFunction)Icn_RegisterIconRefFromResource, 1, + PyDoc_STR("(OSType creator, OSType iconType, FSSpec resourceFile, SInt16 resourceID) -> (IconRef theIconRef)")}, + {"RegisterIconRefFromFSRef", (PyCFunction)Icn_RegisterIconRefFromFSRef, 1, + PyDoc_STR("(OSType creator, OSType iconType, FSRef iconFile) -> (IconRef theIconRef)")}, + {"UnregisterIconRef", (PyCFunction)Icn_UnregisterIconRef, 1, + PyDoc_STR("(OSType creator, OSType iconType) -> None")}, + {"UpdateIconRef", (PyCFunction)Icn_UpdateIconRef, 1, + PyDoc_STR("(IconRef theIconRef) -> None")}, + {"OverrideIconRefFromResource", (PyCFunction)Icn_OverrideIconRefFromResource, 1, + PyDoc_STR("(IconRef theIconRef, FSSpec resourceFile, SInt16 resourceID) -> None")}, + {"OverrideIconRef", (PyCFunction)Icn_OverrideIconRef, 1, + PyDoc_STR("(IconRef oldIconRef, IconRef newIconRef) -> None")}, + {"RemoveIconRefOverride", (PyCFunction)Icn_RemoveIconRefOverride, 1, + PyDoc_STR("(IconRef theIconRef) -> None")}, + {"CompositeIconRef", (PyCFunction)Icn_CompositeIconRef, 1, + PyDoc_STR("(IconRef backgroundIconRef, IconRef foregroundIconRef) -> (IconRef compositeIconRef)")}, + {"IsIconRefComposite", (PyCFunction)Icn_IsIconRefComposite, 1, + PyDoc_STR("(IconRef compositeIconRef) -> (IconRef backgroundIconRef, IconRef foregroundIconRef)")}, + {"IsValidIconRef", (PyCFunction)Icn_IsValidIconRef, 1, + PyDoc_STR("(IconRef theIconRef) -> (Boolean _rv)")}, + {"PlotIconRef", (PyCFunction)Icn_PlotIconRef, 1, + PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> None")}, + {"PtInIconRef", (PyCFunction)Icn_PtInIconRef, 1, + PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)")}, + {"RectInIconRef", (PyCFunction)Icn_RectInIconRef, 1, + PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)")}, + {"IconRefToRgn", (PyCFunction)Icn_IconRefToRgn, 1, + PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> None")}, + {"GetIconSizesFromIconRef", (PyCFunction)Icn_GetIconSizesFromIconRef, 1, + PyDoc_STR("(IconSelectorValue iconSelectorInput, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (IconSelectorValue iconSelectorOutputPtr)")}, + {"FlushIconRefs", (PyCFunction)Icn_FlushIconRefs, 1, + PyDoc_STR("(OSType creator, OSType iconType) -> None")}, + {"FlushIconRefsByVolume", (PyCFunction)Icn_FlushIconRefsByVolume, 1, + PyDoc_STR("(SInt16 vRefNum) -> None")}, + {"SetCustomIconsEnabled", (PyCFunction)Icn_SetCustomIconsEnabled, 1, + PyDoc_STR("(SInt16 vRefNum, Boolean enableCustomIcons) -> None")}, + {"GetCustomIconsEnabled", (PyCFunction)Icn_GetCustomIconsEnabled, 1, + PyDoc_STR("(SInt16 vRefNum) -> (Boolean customIconsEnabled)")}, + {"IsIconRefMaskEmpty", (PyCFunction)Icn_IsIconRefMaskEmpty, 1, + PyDoc_STR("(IconRef iconRef) -> (Boolean _rv)")}, + {"GetIconRefVariant", (PyCFunction)Icn_GetIconRefVariant, 1, + PyDoc_STR("(IconRef inIconRef, OSType inVariant) -> (IconRef _rv, IconTransformType outTransform)")}, + {"RegisterIconRefFromIconFile", (PyCFunction)Icn_RegisterIconRefFromIconFile, 1, + PyDoc_STR("(OSType creator, OSType iconType, FSSpec iconFile) -> (IconRef theIconRef)")}, + {"ReadIconFile", (PyCFunction)Icn_ReadIconFile, 1, + PyDoc_STR("(FSSpec iconFile) -> (IconFamilyHandle iconFamily)")}, + {"ReadIconFromFSRef", (PyCFunction)Icn_ReadIconFromFSRef, 1, + PyDoc_STR("(FSRef ref) -> (IconFamilyHandle iconFamily)")}, + {"WriteIconFile", (PyCFunction)Icn_WriteIconFile, 1, + PyDoc_STR("(IconFamilyHandle iconFamily, FSSpec iconFile) -> None")}, +#endif /* __LP64__ */ + {NULL, NULL, 0} +}; + + + + +void init_Icn(void) +{ + PyObject *m; +#ifndef __LP64__ + PyObject *d; +#endif /* __LP64__ */ + + + + + m = Py_InitModule("_Icn", Icn_methods); +#ifndef __LP64__ + d = PyModule_GetDict(m); + Icn_Error = PyMac_GetOSErrException(); + if (Icn_Error == NULL || + PyDict_SetItemString(d, "Error", Icn_Error) != 0) + return; +#endif /* __LP64__ */ +} + +/* ======================== End module _Icn ========================= */ +