--- /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 <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) ((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 ========================= */
+