diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/res/_Resmodule.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/res/_Resmodule.c Fri Jul 31 15:01:17 2009 +0100 @@ -0,0 +1,1760 @@ + +/* ========================== Module _Res =========================== */ + +#include "Python.h" + + +#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 + +#ifdef USE_TOOLBOX_OBJECT_GLUE +extern PyObject *_ResObj_New(Handle); +extern int _ResObj_Convert(PyObject *, Handle *); +extern PyObject *_OptResObj_New(Handle); +extern int _OptResObj_Convert(PyObject *, Handle *); +#define ResObj_New _ResObj_New +#define ResObj_Convert _ResObj_Convert +#define OptResObj_New _OptResObj_New +#define OptResObj_Convert _OptResObj_Convert +#endif + +/* Function to dispose a resource, with a "normal" calling sequence */ +static void +PyMac_AutoDisposeHandle(Handle h) +{ + DisposeHandle(h); +} + +static PyObject *Res_Error; + +/* ---------------------- Object type Resource ---------------------- */ + +PyTypeObject Resource_Type; + +#define ResObj_Check(x) ((x)->ob_type == &Resource_Type || PyObject_TypeCheck((x), &Resource_Type)) + +typedef struct ResourceObject { + PyObject_HEAD + Handle ob_itself; + void (*ob_freeit)(Handle ptr); +} ResourceObject; + +PyObject *ResObj_New(Handle itself) +{ + ResourceObject *it; + if (itself == NULL) return PyMac_Error(resNotFound); + it = PyObject_NEW(ResourceObject, &Resource_Type); + if (it == NULL) return NULL; + it->ob_itself = itself; + it->ob_freeit = NULL; + return (PyObject *)it; +} + +int ResObj_Convert(PyObject *v, Handle *p_itself) +{ + if (!ResObj_Check(v)) + { + PyObject *tmp; + if ( (tmp=PyObject_CallMethod(v, "as_Resource", "")) ) + { + *p_itself = ((ResourceObject *)tmp)->ob_itself; + Py_DECREF(tmp); + return 1; + } + PyErr_Clear(); + } + if (!ResObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "Resource required"); + return 0; + } + *p_itself = ((ResourceObject *)v)->ob_itself; + return 1; +} + +static void ResObj_dealloc(ResourceObject *self) +{ + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit(self->ob_itself); + } + self->ob_itself = NULL; + self->ob_type->tp_free((PyObject *)self); +} + +static PyObject *ResObj_HomeResFile(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; +#ifndef HomeResFile + PyMac_PRECHECK(HomeResFile); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = HomeResFile(_self->ob_itself); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *ResObj_MacLoadResource(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; +#ifndef MacLoadResource + PyMac_PRECHECK(MacLoadResource); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + MacLoadResource(_self->ob_itself); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *ResObj_ReleaseResource(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; +#ifndef ReleaseResource + PyMac_PRECHECK(ReleaseResource); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + ReleaseResource(_self->ob_itself); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *ResObj_DetachResource(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; +#ifndef DetachResource + PyMac_PRECHECK(DetachResource); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + DetachResource(_self->ob_itself); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *ResObj_GetResAttrs(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; +#ifndef GetResAttrs + PyMac_PRECHECK(GetResAttrs); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetResAttrs(_self->ob_itself); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *ResObj_GetResInfo(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short theID; + ResType theType; + Str255 name; +#ifndef GetResInfo + PyMac_PRECHECK(GetResInfo); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + GetResInfo(_self->ob_itself, + &theID, + &theType, + name); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("hO&O&", + theID, + PyMac_BuildOSType, theType, + PyMac_BuildStr255, name); + return _res; +} + +static PyObject *ResObj_SetResInfo(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short theID; + Str255 name; +#ifndef SetResInfo + PyMac_PRECHECK(SetResInfo); +#endif + if (!PyArg_ParseTuple(_args, "hO&", + &theID, + PyMac_GetStr255, name)) + return NULL; + SetResInfo(_self->ob_itself, + theID, + name); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *ResObj_AddResource(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ResType theType; + short theID; + Str255 name; +#ifndef AddResource + PyMac_PRECHECK(AddResource); +#endif + if (!PyArg_ParseTuple(_args, "O&hO&", + PyMac_GetOSType, &theType, + &theID, + PyMac_GetStr255, name)) + return NULL; + AddResource(_self->ob_itself, + theType, + theID, + name); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *ResObj_GetResourceSizeOnDisk(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + long _rv; +#ifndef GetResourceSizeOnDisk + PyMac_PRECHECK(GetResourceSizeOnDisk); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetResourceSizeOnDisk(_self->ob_itself); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *ResObj_GetMaxResourceSize(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + long _rv; +#ifndef GetMaxResourceSize + PyMac_PRECHECK(GetMaxResourceSize); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMaxResourceSize(_self->ob_itself); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *ResObj_SetResAttrs(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short attrs; +#ifndef SetResAttrs + PyMac_PRECHECK(SetResAttrs); +#endif + if (!PyArg_ParseTuple(_args, "h", + &attrs)) + return NULL; + SetResAttrs(_self->ob_itself, + attrs); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *ResObj_ChangedResource(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; +#ifndef ChangedResource + PyMac_PRECHECK(ChangedResource); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + ChangedResource(_self->ob_itself); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *ResObj_RemoveResource(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; +#ifndef RemoveResource + PyMac_PRECHECK(RemoveResource); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + RemoveResource(_self->ob_itself); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *ResObj_WriteResource(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; +#ifndef WriteResource + PyMac_PRECHECK(WriteResource); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + WriteResource(_self->ob_itself); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *ResObj_SetResourceSize(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + long newSize; +#ifndef SetResourceSize + PyMac_PRECHECK(SetResourceSize); +#endif + if (!PyArg_ParseTuple(_args, "l", + &newSize)) + return NULL; + SetResourceSize(_self->ob_itself, + newSize); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *ResObj_GetNextFOND(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Handle _rv; +#ifndef GetNextFOND + PyMac_PRECHECK(GetNextFOND); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetNextFOND(_self->ob_itself); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +#ifndef __LP64__ +static PyObject *ResObj_as_Control(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + + _res = CtlObj_New((ControlHandle)_self->ob_itself); + return _res; + +} + +static PyObject *ResObj_as_Menu(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + + _res = MenuObj_New((MenuHandle)_self->ob_itself); + return _res; + +} +#endif /* !__LP64__ */ + +static PyObject *ResObj_LoadResource(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; +#ifndef LoadResource + PyMac_PRECHECK(LoadResource); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + LoadResource(_self->ob_itself); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *ResObj_AutoDispose(ResourceObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + + int onoff, old = 0; + if (!PyArg_ParseTuple(_args, "i", &onoff)) + return NULL; + if ( _self->ob_freeit ) + old = 1; + if ( onoff ) + _self->ob_freeit = PyMac_AutoDisposeHandle; + else + _self->ob_freeit = NULL; + _res = Py_BuildValue("i", old); + return _res; + +} + +static PyMethodDef ResObj_methods[] = { + {"HomeResFile", (PyCFunction)ResObj_HomeResFile, 1, + PyDoc_STR("() -> (short _rv)")}, + {"MacLoadResource", (PyCFunction)ResObj_MacLoadResource, 1, + PyDoc_STR("() -> None")}, + {"ReleaseResource", (PyCFunction)ResObj_ReleaseResource, 1, + PyDoc_STR("() -> None")}, + {"DetachResource", (PyCFunction)ResObj_DetachResource, 1, + PyDoc_STR("() -> None")}, + {"GetResAttrs", (PyCFunction)ResObj_GetResAttrs, 1, + PyDoc_STR("() -> (short _rv)")}, + {"GetResInfo", (PyCFunction)ResObj_GetResInfo, 1, + PyDoc_STR("() -> (short theID, ResType theType, Str255 name)")}, + {"SetResInfo", (PyCFunction)ResObj_SetResInfo, 1, + PyDoc_STR("(short theID, Str255 name) -> None")}, + {"AddResource", (PyCFunction)ResObj_AddResource, 1, + PyDoc_STR("(ResType theType, short theID, Str255 name) -> None")}, + {"GetResourceSizeOnDisk", (PyCFunction)ResObj_GetResourceSizeOnDisk, 1, + PyDoc_STR("() -> (long _rv)")}, + {"GetMaxResourceSize", (PyCFunction)ResObj_GetMaxResourceSize, 1, + PyDoc_STR("() -> (long _rv)")}, + {"SetResAttrs", (PyCFunction)ResObj_SetResAttrs, 1, + PyDoc_STR("(short attrs) -> None")}, + {"ChangedResource", (PyCFunction)ResObj_ChangedResource, 1, + PyDoc_STR("() -> None")}, + {"RemoveResource", (PyCFunction)ResObj_RemoveResource, 1, + PyDoc_STR("() -> None")}, + {"WriteResource", (PyCFunction)ResObj_WriteResource, 1, + PyDoc_STR("() -> None")}, + {"SetResourceSize", (PyCFunction)ResObj_SetResourceSize, 1, + PyDoc_STR("(long newSize) -> None")}, + {"GetNextFOND", (PyCFunction)ResObj_GetNextFOND, 1, + PyDoc_STR("() -> (Handle _rv)")}, +#ifndef __LP64__ + {"as_Control", (PyCFunction)ResObj_as_Control, 1, + PyDoc_STR("Return this resource/handle as a Control")}, + {"as_Menu", (PyCFunction)ResObj_as_Menu, 1, + PyDoc_STR("Return this resource/handle as a Menu")}, +#endif /* !__LP64__ */ + {"LoadResource", (PyCFunction)ResObj_LoadResource, 1, + PyDoc_STR("() -> None")}, + {"AutoDispose", (PyCFunction)ResObj_AutoDispose, 1, + PyDoc_STR("(int)->int. Automatically DisposeHandle the object on Python object cleanup")}, + {NULL, NULL, 0} +}; + +static PyObject *ResObj_get_data(ResourceObject *self, void *closure) +{ + + PyObject *res; + char state; + + state = HGetState(self->ob_itself); + HLock(self->ob_itself); + res = PyString_FromStringAndSize( + *self->ob_itself, + GetHandleSize(self->ob_itself)); + HUnlock(self->ob_itself); + HSetState(self->ob_itself, state); + return res; + +} + +static int ResObj_set_data(ResourceObject *self, PyObject *v, void *closure) +{ + + char *data; + long size; + + if ( v == NULL ) + return -1; + if ( !PyString_Check(v) ) + return -1; + size = PyString_Size(v); + data = PyString_AsString(v); + /* XXXX Do I need the GetState/SetState calls? */ + SetHandleSize(self->ob_itself, size); + if ( MemError()) + return -1; + HLock(self->ob_itself); + memcpy((char *)*self->ob_itself, data, size); + HUnlock(self->ob_itself); + /* XXXX Should I do the Changed call immedeately? */ + return 0; + + return 0; +} + +static PyObject *ResObj_get_size(ResourceObject *self, void *closure) +{ + return PyInt_FromLong(GetHandleSize(self->ob_itself)); +} + +#define ResObj_set_size NULL + +static PyGetSetDef ResObj_getsetlist[] = { + {"data", (getter)ResObj_get_data, (setter)ResObj_set_data, "The resource data"}, + {"size", (getter)ResObj_get_size, (setter)ResObj_set_size, "The length of the resource data"}, + {NULL, NULL, NULL, NULL}, +}; + + +#define ResObj_compare NULL + +#define ResObj_repr NULL + +#define ResObj_hash NULL +static int ResObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) +{ + char *srcdata = NULL; + int srclen = 0; + Handle itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, ResObj_Convert, &itself)) + { + ((ResourceObject *)_self)->ob_itself = itself; + return 0; + } + PyErr_Clear(); + if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "|s#", kw, &srcdata, &srclen)) return -1; + if ((itself = NewHandle(srclen)) == NULL) + { + PyErr_NoMemory(); + return 0; + } + ((ResourceObject *)_self)->ob_itself = itself; + if (srclen && srcdata) + { + HLock(itself); + memcpy(*itself, srcdata, srclen); + HUnlock(itself); + } + return 0; +} + +#define ResObj_tp_alloc PyType_GenericAlloc + +static PyObject *ResObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((ResourceObject *)self)->ob_itself = NULL; + ((ResourceObject *)self)->ob_freeit = NULL; + return self; +} + +#define ResObj_tp_free PyObject_Del + + +PyTypeObject Resource_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_Res.Resource", /*tp_name*/ + sizeof(ResourceObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) ResObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ + (cmpfunc) ResObj_compare, /*tp_compare*/ + (reprfunc) ResObj_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) ResObj_hash, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr, /*tp_getattro*/ + PyObject_GenericSetAttr, /*tp_setattro */ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + ResObj_methods, /* tp_methods */ + 0, /*tp_members*/ + ResObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + ResObj_tp_init, /* tp_init */ + ResObj_tp_alloc, /* tp_alloc */ + ResObj_tp_new, /* tp_new */ + ResObj_tp_free, /* tp_free */ +}; + +/* -------------------- End object type Resource -------------------- */ + + +static PyObject *Res_CloseResFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short refNum; +#ifndef CloseResFile + PyMac_PRECHECK(CloseResFile); +#endif + if (!PyArg_ParseTuple(_args, "h", + &refNum)) + return NULL; + CloseResFile(refNum); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Res_ResError(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; +#ifndef ResError + PyMac_PRECHECK(ResError); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Res_CurResFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; +#ifndef CurResFile + PyMac_PRECHECK(CurResFile); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CurResFile(); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *Res_UseResFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short refNum; +#ifndef UseResFile + PyMac_PRECHECK(UseResFile); +#endif + if (!PyArg_ParseTuple(_args, "h", + &refNum)) + return NULL; + UseResFile(refNum); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Res_CountTypes(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; +#ifndef CountTypes + PyMac_PRECHECK(CountTypes); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CountTypes(); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *Res_Count1Types(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; +#ifndef Count1Types + PyMac_PRECHECK(Count1Types); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = Count1Types(); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *Res_GetIndType(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ResType theType; + short index; +#ifndef GetIndType + PyMac_PRECHECK(GetIndType); +#endif + if (!PyArg_ParseTuple(_args, "h", + &index)) + return NULL; + GetIndType(&theType, + index); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("O&", + PyMac_BuildOSType, theType); + return _res; +} + +static PyObject *Res_Get1IndType(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + ResType theType; + short index; +#ifndef Get1IndType + PyMac_PRECHECK(Get1IndType); +#endif + if (!PyArg_ParseTuple(_args, "h", + &index)) + return NULL; + Get1IndType(&theType, + index); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("O&", + PyMac_BuildOSType, theType); + return _res; +} + +static PyObject *Res_SetResLoad(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean load; +#ifndef SetResLoad + PyMac_PRECHECK(SetResLoad); +#endif + if (!PyArg_ParseTuple(_args, "b", + &load)) + return NULL; + SetResLoad(load); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Res_CountResources(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; + ResType theType; +#ifndef CountResources + PyMac_PRECHECK(CountResources); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetOSType, &theType)) + return NULL; + _rv = CountResources(theType); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *Res_Count1Resources(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; + ResType theType; +#ifndef Count1Resources + PyMac_PRECHECK(Count1Resources); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetOSType, &theType)) + return NULL; + _rv = Count1Resources(theType); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *Res_GetIndResource(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Handle _rv; + ResType theType; + short index; +#ifndef GetIndResource + PyMac_PRECHECK(GetIndResource); +#endif + if (!PyArg_ParseTuple(_args, "O&h", + PyMac_GetOSType, &theType, + &index)) + return NULL; + _rv = GetIndResource(theType, + index); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *Res_Get1IndResource(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Handle _rv; + ResType theType; + short index; +#ifndef Get1IndResource + PyMac_PRECHECK(Get1IndResource); +#endif + if (!PyArg_ParseTuple(_args, "O&h", + PyMac_GetOSType, &theType, + &index)) + return NULL; + _rv = Get1IndResource(theType, + index); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *Res_GetResource(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Handle _rv; + ResType theType; + short theID; +#ifndef GetResource + PyMac_PRECHECK(GetResource); +#endif + if (!PyArg_ParseTuple(_args, "O&h", + PyMac_GetOSType, &theType, + &theID)) + return NULL; + _rv = GetResource(theType, + theID); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *Res_Get1Resource(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Handle _rv; + ResType theType; + short theID; +#ifndef Get1Resource + PyMac_PRECHECK(Get1Resource); +#endif + if (!PyArg_ParseTuple(_args, "O&h", + PyMac_GetOSType, &theType, + &theID)) + return NULL; + _rv = Get1Resource(theType, + theID); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *Res_GetNamedResource(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Handle _rv; + ResType theType; + Str255 name; +#ifndef GetNamedResource + PyMac_PRECHECK(GetNamedResource); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetOSType, &theType, + PyMac_GetStr255, name)) + return NULL; + _rv = GetNamedResource(theType, + name); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *Res_Get1NamedResource(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Handle _rv; + ResType theType; + Str255 name; +#ifndef Get1NamedResource + PyMac_PRECHECK(Get1NamedResource); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetOSType, &theType, + PyMac_GetStr255, name)) + return NULL; + _rv = Get1NamedResource(theType, + name); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("O&", + ResObj_New, _rv); + return _res; +} + +static PyObject *Res_UniqueID(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; + ResType theType; +#ifndef UniqueID + PyMac_PRECHECK(UniqueID); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetOSType, &theType)) + return NULL; + _rv = UniqueID(theType); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *Res_Unique1ID(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; + ResType theType; +#ifndef Unique1ID + PyMac_PRECHECK(Unique1ID); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetOSType, &theType)) + return NULL; + _rv = Unique1ID(theType); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *Res_UpdateResFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short refNum; +#ifndef UpdateResFile + PyMac_PRECHECK(UpdateResFile); +#endif + if (!PyArg_ParseTuple(_args, "h", + &refNum)) + return NULL; + UpdateResFile(refNum); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Res_SetResPurge(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean install; +#ifndef SetResPurge + PyMac_PRECHECK(SetResPurge); +#endif + if (!PyArg_ParseTuple(_args, "b", + &install)) + return NULL; + SetResPurge(install); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Res_GetResFileAttrs(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; + short refNum; +#ifndef GetResFileAttrs + PyMac_PRECHECK(GetResFileAttrs); +#endif + if (!PyArg_ParseTuple(_args, "h", + &refNum)) + return NULL; + _rv = GetResFileAttrs(refNum); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *Res_SetResFileAttrs(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short refNum; + short attrs; +#ifndef SetResFileAttrs + PyMac_PRECHECK(SetResFileAttrs); +#endif + if (!PyArg_ParseTuple(_args, "hh", + &refNum, + &attrs)) + return NULL; + SetResFileAttrs(refNum, + attrs); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +#ifndef __LP64__ +static PyObject *Res_OpenRFPerm(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; + Str255 fileName; + short vRefNum; + SignedByte permission; +#ifndef OpenRFPerm + PyMac_PRECHECK(OpenRFPerm); +#endif + if (!PyArg_ParseTuple(_args, "O&hb", + PyMac_GetStr255, fileName, + &vRefNum, + &permission)) + return NULL; + _rv = OpenRFPerm(fileName, + vRefNum, + permission); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *Res_HOpenResFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; + short vRefNum; + long dirID; + Str255 fileName; + SignedByte permission; +#ifndef HOpenResFile + PyMac_PRECHECK(HOpenResFile); +#endif + if (!PyArg_ParseTuple(_args, "hlO&b", + &vRefNum, + &dirID, + PyMac_GetStr255, fileName, + &permission)) + return NULL; + _rv = HOpenResFile(vRefNum, + dirID, + fileName, + permission); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *Res_HCreateResFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short vRefNum; + long dirID; + Str255 fileName; +#ifndef HCreateResFile + PyMac_PRECHECK(HCreateResFile); +#endif + if (!PyArg_ParseTuple(_args, "hlO&", + &vRefNum, + &dirID, + PyMac_GetStr255, fileName)) + return NULL; + HCreateResFile(vRefNum, + dirID, + fileName); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Res_FSpOpenResFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; + FSSpec spec; + SignedByte permission; +#ifndef FSpOpenResFile + PyMac_PRECHECK(FSpOpenResFile); +#endif + if (!PyArg_ParseTuple(_args, "O&b", + PyMac_GetFSSpec, &spec, + &permission)) + return NULL; + _rv = FSpOpenResFile(&spec, + permission); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("h", + _rv); + return _res; +} + +static PyObject *Res_FSpCreateResFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + FSSpec spec; + OSType creator; + OSType fileType; + ScriptCode scriptTag; +#ifndef FSpCreateResFile + PyMac_PRECHECK(FSpCreateResFile); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&h", + PyMac_GetFSSpec, &spec, + PyMac_GetOSType, &creator, + PyMac_GetOSType, &fileType, + &scriptTag)) + return NULL; + FSpCreateResFile(&spec, + creator, + fileType, + scriptTag); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} +#endif /* !__LP64__ */ + +static PyObject *Res_InsertResourceFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 refNum; + RsrcChainLocation where; +#ifndef InsertResourceFile + PyMac_PRECHECK(InsertResourceFile); +#endif + if (!PyArg_ParseTuple(_args, "hh", + &refNum, + &where)) + return NULL; + _err = InsertResourceFile(refNum, + where); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Res_DetachResourceFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 refNum; +#ifndef DetachResourceFile + PyMac_PRECHECK(DetachResourceFile); +#endif + if (!PyArg_ParseTuple(_args, "h", + &refNum)) + return NULL; + _err = DetachResourceFile(refNum); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +#ifndef __LP64__ +static PyObject *Res_FSpResourceFileAlreadyOpen(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + FSSpec resourceFile; + Boolean inChain; + SInt16 refNum; +#ifndef FSpResourceFileAlreadyOpen + PyMac_PRECHECK(FSpResourceFileAlreadyOpen); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSSpec, &resourceFile)) + return NULL; + _rv = FSpResourceFileAlreadyOpen(&resourceFile, + &inChain, + &refNum); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("bbh", + _rv, + inChain, + refNum); + return _res; +} + +static PyObject *Res_FSpOpenOrphanResFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec spec; + SignedByte permission; + SInt16 refNum; +#ifndef FSpOpenOrphanResFile + PyMac_PRECHECK(FSpOpenOrphanResFile); +#endif + if (!PyArg_ParseTuple(_args, "O&b", + PyMac_GetFSSpec, &spec, + &permission)) + return NULL; + _err = FSpOpenOrphanResFile(&spec, + permission, + &refNum); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + refNum); + return _res; +} + +static PyObject *Res_GetTopResourceFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 refNum; +#ifndef GetTopResourceFile + PyMac_PRECHECK(GetTopResourceFile); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = GetTopResourceFile(&refNum); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + refNum); + return _res; +} + + +static PyObject *Res_GetNextResourceFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 curRefNum; + SInt16 nextRefNum; +#ifndef GetNextResourceFile + PyMac_PRECHECK(GetNextResourceFile); +#endif + if (!PyArg_ParseTuple(_args, "h", + &curRefNum)) + return NULL; + _err = GetNextResourceFile(curRefNum, + &nextRefNum); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + nextRefNum); + return _res; +} +#endif /* !__LP64__ */ + +static PyObject *Res_FSOpenResFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + short _rv; + FSRef ref; + SignedByte permission; +#ifndef FSOpenResFile + PyMac_PRECHECK(FSOpenResFile); +#endif + if (!PyArg_ParseTuple(_args, "O&b", + PyMac_GetFSRef, &ref, + &permission)) + return NULL; + _rv = FSOpenResFile(&ref, + permission); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("h", + _rv); + return _res; +} + + +#ifndef __LP64__ +static PyObject *Res_FSCreateResFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + FSRef parentRef; + UniChar *nameLength__in__; + UniCharCount nameLength__len__; + int nameLength__in_len__; + FSRef newRef; + FSSpec newSpec; +#ifndef FSCreateResFile + PyMac_PRECHECK(FSCreateResFile); +#endif + if (!PyArg_ParseTuple(_args, "O&u#", + PyMac_GetFSRef, &parentRef, + &nameLength__in__, &nameLength__in_len__)) + return NULL; + nameLength__len__ = nameLength__in_len__; + FSCreateResFile(&parentRef, + nameLength__len__, nameLength__in__, + 0, + (FSCatalogInfo *)0, + &newRef, + &newSpec); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("O&O&", + PyMac_BuildFSRef, &newRef, + PyMac_BuildFSSpec, &newSpec); + return _res; +} + +static PyObject *Res_FSResourceFileAlreadyOpen(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + FSRef resourceFileRef; + Boolean inChain; + SInt16 refNum; +#ifndef FSResourceFileAlreadyOpen + PyMac_PRECHECK(FSResourceFileAlreadyOpen); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSRef, &resourceFileRef)) + return NULL; + _rv = FSResourceFileAlreadyOpen(&resourceFileRef, + &inChain, + &refNum); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("bbh", + _rv, + inChain, + refNum); + return _res; +} + +static PyObject *Res_FSCreateResourceFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef parentRef; + UniChar *nameLength__in__; + UniCharCount nameLength__len__; + int nameLength__in_len__; + UniChar *forkNameLength__in__; + UniCharCount forkNameLength__len__; + int forkNameLength__in_len__; + FSRef newRef; + FSSpec newSpec; +#ifndef FSCreateResourceFile + PyMac_PRECHECK(FSCreateResourceFile); +#endif + if (!PyArg_ParseTuple(_args, "O&u#u#", + PyMac_GetFSRef, &parentRef, + &nameLength__in__, &nameLength__in_len__, + &forkNameLength__in__, &forkNameLength__in_len__)) + return NULL; + nameLength__len__ = nameLength__in_len__; + forkNameLength__len__ = forkNameLength__in_len__; + _err = FSCreateResourceFile(&parentRef, + nameLength__len__, nameLength__in__, + 0, + (FSCatalogInfo *)0, + forkNameLength__len__, forkNameLength__in__, + &newRef, + &newSpec); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&O&", + PyMac_BuildFSRef, &newRef, + PyMac_BuildFSSpec, &newSpec); + return _res; +} +#endif /* __LP64__ */ + +static PyObject *Res_FSOpenResourceFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef ref; + UniChar *forkNameLength__in__; + UniCharCount forkNameLength__len__; + int forkNameLength__in_len__; + SignedByte permissions; + ResFileRefNum refNum; +#ifndef FSOpenResourceFile + PyMac_PRECHECK(FSOpenResourceFile); +#endif + if (!PyArg_ParseTuple(_args, "O&u#b", + PyMac_GetFSRef, &ref, + &forkNameLength__in__, &forkNameLength__in_len__, + &permissions)) + return NULL; + forkNameLength__len__ = forkNameLength__in_len__; + _err = FSOpenResourceFile(&ref, + forkNameLength__len__, forkNameLength__in__, + permissions, + &refNum); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + refNum); + return _res; +} + +static PyObject *Res_Handle(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + + char *buf; + int len; + Handle h; + ResourceObject *rv; + + if (!PyArg_ParseTuple(_args, "s#", &buf, &len)) + return NULL; + h = NewHandle(len); + if ( h == NULL ) { + PyErr_NoMemory(); + return NULL; + } + HLock(h); + memcpy(*h, buf, len); + HUnlock(h); + rv = (ResourceObject *)ResObj_New(h); + rv->ob_freeit = PyMac_AutoDisposeHandle; + _res = (PyObject *)rv; + return _res; + +} + +static PyMethodDef Res_methods[] = { + {"CloseResFile", (PyCFunction)Res_CloseResFile, 1, + PyDoc_STR("(short refNum) -> None")}, + {"ResError", (PyCFunction)Res_ResError, 1, + PyDoc_STR("() -> None")}, + {"CurResFile", (PyCFunction)Res_CurResFile, 1, + PyDoc_STR("() -> (short _rv)")}, + {"UseResFile", (PyCFunction)Res_UseResFile, 1, + PyDoc_STR("(short refNum) -> None")}, + {"CountTypes", (PyCFunction)Res_CountTypes, 1, + PyDoc_STR("() -> (short _rv)")}, + {"Count1Types", (PyCFunction)Res_Count1Types, 1, + PyDoc_STR("() -> (short _rv)")}, + {"GetIndType", (PyCFunction)Res_GetIndType, 1, + PyDoc_STR("(short index) -> (ResType theType)")}, + {"Get1IndType", (PyCFunction)Res_Get1IndType, 1, + PyDoc_STR("(short index) -> (ResType theType)")}, + {"SetResLoad", (PyCFunction)Res_SetResLoad, 1, + PyDoc_STR("(Boolean load) -> None")}, + {"CountResources", (PyCFunction)Res_CountResources, 1, + PyDoc_STR("(ResType theType) -> (short _rv)")}, + {"Count1Resources", (PyCFunction)Res_Count1Resources, 1, + PyDoc_STR("(ResType theType) -> (short _rv)")}, + {"GetIndResource", (PyCFunction)Res_GetIndResource, 1, + PyDoc_STR("(ResType theType, short index) -> (Handle _rv)")}, + {"Get1IndResource", (PyCFunction)Res_Get1IndResource, 1, + PyDoc_STR("(ResType theType, short index) -> (Handle _rv)")}, + {"GetResource", (PyCFunction)Res_GetResource, 1, + PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")}, + {"Get1Resource", (PyCFunction)Res_Get1Resource, 1, + PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")}, + {"GetNamedResource", (PyCFunction)Res_GetNamedResource, 1, + PyDoc_STR("(ResType theType, Str255 name) -> (Handle _rv)")}, + {"Get1NamedResource", (PyCFunction)Res_Get1NamedResource, 1, + PyDoc_STR("(ResType theType, Str255 name) -> (Handle _rv)")}, + {"UniqueID", (PyCFunction)Res_UniqueID, 1, + PyDoc_STR("(ResType theType) -> (short _rv)")}, + {"Unique1ID", (PyCFunction)Res_Unique1ID, 1, + PyDoc_STR("(ResType theType) -> (short _rv)")}, + {"UpdateResFile", (PyCFunction)Res_UpdateResFile, 1, + PyDoc_STR("(short refNum) -> None")}, + {"SetResPurge", (PyCFunction)Res_SetResPurge, 1, + PyDoc_STR("(Boolean install) -> None")}, + {"GetResFileAttrs", (PyCFunction)Res_GetResFileAttrs, 1, + PyDoc_STR("(short refNum) -> (short _rv)")}, + {"SetResFileAttrs", (PyCFunction)Res_SetResFileAttrs, 1, + PyDoc_STR("(short refNum, short attrs) -> None")}, +#ifndef __LP64__ + {"OpenRFPerm", (PyCFunction)Res_OpenRFPerm, 1, + PyDoc_STR("(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)")}, + {"HOpenResFile", (PyCFunction)Res_HOpenResFile, 1, + PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)")}, + {"HCreateResFile", (PyCFunction)Res_HCreateResFile, 1, + PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")}, + {"FSpOpenResFile", (PyCFunction)Res_FSpOpenResFile, 1, + PyDoc_STR("(FSSpec spec, SignedByte permission) -> (short _rv)")}, + {"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1, + PyDoc_STR("(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None")}, +#endif /* !__LP64__ */ + {"InsertResourceFile", (PyCFunction)Res_InsertResourceFile, 1, + PyDoc_STR("(SInt16 refNum, RsrcChainLocation where) -> None")}, + {"DetachResourceFile", (PyCFunction)Res_DetachResourceFile, 1, + PyDoc_STR("(SInt16 refNum) -> None")}, +#ifndef __LP64__ + {"FSpResourceFileAlreadyOpen", (PyCFunction)Res_FSpResourceFileAlreadyOpen, 1, + PyDoc_STR("(FSSpec resourceFile) -> (Boolean _rv, Boolean inChain, SInt16 refNum)")}, + {"FSpOpenOrphanResFile", (PyCFunction)Res_FSpOpenOrphanResFile, 1, + PyDoc_STR("(FSSpec spec, SignedByte permission) -> (SInt16 refNum)")}, + {"GetTopResourceFile", (PyCFunction)Res_GetTopResourceFile, 1, + PyDoc_STR("() -> (SInt16 refNum)")}, + {"GetNextResourceFile", (PyCFunction)Res_GetNextResourceFile, 1, + PyDoc_STR("(SInt16 curRefNum) -> (SInt16 nextRefNum)")}, +#endif /* __LP64__ */ + {"FSOpenResFile", (PyCFunction)Res_FSOpenResFile, 1, + PyDoc_STR("(FSRef ref, SignedByte permission) -> (short _rv)")}, +#ifndef __LP64__ + {"FSCreateResFile", (PyCFunction)Res_FSCreateResFile, 1, + PyDoc_STR("(FSRef parentRef, Buffer nameLength) -> (FSRef newRef, FSSpec newSpec)")}, + {"FSResourceFileAlreadyOpen", (PyCFunction)Res_FSResourceFileAlreadyOpen, 1, + PyDoc_STR("(FSRef resourceFileRef) -> (Boolean _rv, Boolean inChain, SInt16 refNum)")}, + {"FSCreateResourceFile", (PyCFunction)Res_FSCreateResourceFile, 1, + PyDoc_STR("(FSRef parentRef, Buffer nameLength, Buffer forkNameLength) -> (FSRef newRef, FSSpec newSpec)")}, +#endif /* __LP64__ */ + {"FSOpenResourceFile", (PyCFunction)Res_FSOpenResourceFile, 1, + PyDoc_STR("(FSRef ref, Buffer forkNameLength, SignedByte permissions) -> (SInt16 refNum)")}, + {"Handle", (PyCFunction)Res_Handle, 1, + PyDoc_STR("Convert a string to a Handle object.\n\nResource() and Handle() are very similar, but objects created with Handle() are\nby default automatically DisposeHandle()d upon object cleanup. Use AutoDispose()\nto change this.\n")}, + {NULL, NULL, 0} +}; + + + +/* Alternative version of ResObj_New, which returns None for null argument */ +PyObject *OptResObj_New(Handle itself) +{ + if (itself == NULL) { + Py_INCREF(Py_None); + return Py_None; + } + return ResObj_New(itself); +} + +int OptResObj_Convert(PyObject *v, Handle *p_itself) +{ + PyObject *tmp; + + if ( v == Py_None ) { + *p_itself = NULL; + return 1; + } + if (ResObj_Check(v)) + { + *p_itself = ((ResourceObject *)v)->ob_itself; + return 1; + } + /* If it isn't a resource yet see whether it is convertible */ + if ( (tmp=PyObject_CallMethod(v, "as_Resource", "")) ) { + *p_itself = ((ResourceObject *)tmp)->ob_itself; + Py_DECREF(tmp); + return 1; + } + PyErr_Clear(); + PyErr_SetString(PyExc_TypeError, "Resource required"); + return 0; +} + + +void init_Res(void) +{ + PyObject *m; + PyObject *d; + + + + PyMac_INIT_TOOLBOX_OBJECT_NEW(Handle, ResObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Handle, ResObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(Handle, OptResObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Handle, OptResObj_Convert); + + + m = Py_InitModule("_Res", Res_methods); + d = PyModule_GetDict(m); + Res_Error = PyMac_GetOSErrException(); + if (Res_Error == NULL || + PyDict_SetItemString(d, "Error", Res_Error) != 0) + return; + Resource_Type.ob_type = &PyType_Type; + if (PyType_Ready(&Resource_Type) < 0) return; + Py_INCREF(&Resource_Type); + PyModule_AddObject(m, "Resource", (PyObject *)&Resource_Type); + /* Backward-compatible name */ + Py_INCREF(&Resource_Type); + PyModule_AddObject(m, "ResourceType", (PyObject *)&Resource_Type); +} + +/* ======================== End module _Res ========================= */ +