| |
| /* ========================== 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 <Carbon/Carbon.h> |
| |
| #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) (Py_Type(x) == &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; |
| Py_Type(self)->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; |
| } |
| |
| 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; |
| |
| } |
| |
| 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)")}, |
| {"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")}, |
| {"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 = { |
| PyVarObject_HEAD_INIT(NULL, 0) |
| "_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; |
| } |
| |
| 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; |
| } |
| |
| 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; |
| } |
| |
| 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; |
| } |
| |
| 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; |
| } |
| |
| 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; |
| } |
| |
| 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; |
| SInt16 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")}, |
| {"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")}, |
| {"InsertResourceFile", (PyCFunction)Res_InsertResourceFile, 1, |
| PyDoc_STR("(SInt16 refNum, RsrcChainLocation where) -> None")}, |
| {"DetachResourceFile", (PyCFunction)Res_DetachResourceFile, 1, |
| PyDoc_STR("(SInt16 refNum) -> None")}, |
| {"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)")}, |
| {"FSOpenResFile", (PyCFunction)Res_FSOpenResFile, 1, |
| PyDoc_STR("(FSRef ref, SignedByte permission) -> (short _rv)")}, |
| {"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)")}, |
| {"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; |
| Py_Type(&Resource_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 ========================= */ |
| |