Committed a more or less working version.

1 files changed, 1256 insertions, 0 deletions

diff --git a/Mac/Modules/res/Resmodule.c b/Mac/Modules/res/Resmodule.c
new file mode 100644
index 0000000..484bca6
--- /dev/null
+++ b/Mac/Modules/res/Resmodule.c
@@ -0,0 +1,1256 @@
+
+/* =========================== Module Res =========================== */
+
+#include "Python.h"
+
+
+
+#define SystemSevenOrLater 1
+
+#include "macglue.h"
+#include <Memory.h>
+#include <Dialogs.h>
+#include <Menus.h>
+#include <Controls.h>
+
+extern PyObject *ResObj_New(Handle);
+extern int ResObj_Convert(PyObject *, Handle *);
+
+extern PyObject *WinObj_New(WindowPtr);
+extern int WinObj_Convert(PyObject *, WindowPtr *);
+
+extern PyObject *DlgObj_New(DialogPtr);
+extern int DlgObj_Convert(PyObject *, DialogPtr *);
+extern PyTypeObject Dialog_Type;
+#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
+
+extern PyObject *MenuObj_New(MenuHandle);
+extern int MenuObj_Convert(PyObject *, MenuHandle *);
+
+extern PyObject *CtlObj_New(ControlHandle);
+extern int CtlObj_Convert(PyObject *, ControlHandle *);
+
+#include <Resources.h>
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+
+static PyObject *Res_Error;
+
+/* ---------------------- Object type Resource ---------------------- */
+
+PyTypeObject Resource_Type;
+
+#define ResObj_Check(x) ((x)->ob_type == &Resource_Type)
+
+typedef struct ResourceObject {
+	PyObject_HEAD
+	Handle ob_itself;
+} ResourceObject;
+
+PyObject *ResObj_New(itself)
+	const 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;
+	return (PyObject *)it;
+}
+ResObj_Convert(v, p_itself)
+	PyObject *v;
+	Handle *p_itself;
+{
+	if (!ResObj_Check(v))
+	{
+		PyErr_SetString(PyExc_TypeError, "Resource required");
+		return 0;
+	}
+	*p_itself = ((ResourceObject *)v)->ob_itself;
+	return 1;
+}
+
+static void ResObj_dealloc(self)
+	ResourceObject *self;
+{
+	/* Cleanup of self->ob_itself goes here */
+	PyMem_DEL(self);
+}
+
+static PyObject *ResObj_HomeResFile(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	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_LoadResource(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	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_ReleaseResource(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	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(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	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(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	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(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short theID;
+	ResType theType;
+	Str255 name;
+	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(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short theID;
+	Str255 name;
+	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(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	ResType theType;
+	short theID;
+	Str255 name;
+	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_SizeResource(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = SizeResource(_self->ob_itself);
+	{
+		OSErr _err = ResError();
+		if (_err != noErr) return PyMac_Error(_err);
+	}
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *ResObj_MaxSizeRsrc(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = MaxSizeRsrc(_self->ob_itself);
+	{
+		OSErr _err = ResError();
+		if (_err != noErr) return PyMac_Error(_err);
+	}
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *ResObj_RsrcMapEntry(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = RsrcMapEntry(_self->ob_itself);
+	{
+		OSErr _err = ResError();
+		if (_err != noErr) return PyMac_Error(_err);
+	}
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *ResObj_SetResAttrs(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short attrs;
+	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(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	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_RmveResource(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	RmveResource(_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(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	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(_self, _args)
+	ResourceObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long newSize;
+	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 PyMethodDef ResObj_methods[] = {
+	{"HomeResFile", (PyCFunction)ResObj_HomeResFile, 1,
+	 "() -> (short _rv)"},
+	{"LoadResource", (PyCFunction)ResObj_LoadResource, 1,
+	 "() -> None"},
+	{"ReleaseResource", (PyCFunction)ResObj_ReleaseResource, 1,
+	 "() -> None"},
+	{"DetachResource", (PyCFunction)ResObj_DetachResource, 1,
+	 "() -> None"},
+	{"GetResAttrs", (PyCFunction)ResObj_GetResAttrs, 1,
+	 "() -> (short _rv)"},
+	{"GetResInfo", (PyCFunction)ResObj_GetResInfo, 1,
+	 "() -> (short theID, ResType theType, Str255 name)"},
+	{"SetResInfo", (PyCFunction)ResObj_SetResInfo, 1,
+	 "(short theID, Str255 name) -> None"},
+	{"AddResource", (PyCFunction)ResObj_AddResource, 1,
+	 "(ResType theType, short theID, Str255 name) -> None"},
+	{"SizeResource", (PyCFunction)ResObj_SizeResource, 1,
+	 "() -> (long _rv)"},
+	{"MaxSizeRsrc", (PyCFunction)ResObj_MaxSizeRsrc, 1,
+	 "() -> (long _rv)"},
+	{"RsrcMapEntry", (PyCFunction)ResObj_RsrcMapEntry, 1,
+	 "() -> (long _rv)"},
+	{"SetResAttrs", (PyCFunction)ResObj_SetResAttrs, 1,
+	 "(short attrs) -> None"},
+	{"ChangedResource", (PyCFunction)ResObj_ChangedResource, 1,
+	 "() -> None"},
+	{"RmveResource", (PyCFunction)ResObj_RmveResource, 1,
+	 "() -> None"},
+	{"WriteResource", (PyCFunction)ResObj_WriteResource, 1,
+	 "() -> None"},
+	{"SetResourceSize", (PyCFunction)ResObj_SetResourceSize, 1,
+	 "(long newSize) -> None"},
+	{NULL, NULL, 0}
+};
+
+PyMethodChain ResObj_chain = { ResObj_methods, NULL };
+
+static PyObject *ResObj_getattr(self, name)
+	ResourceObject *self;
+	char *name;
+{
+
+	if (strcmp(name, "size") == 0)
+		return PyInt_FromLong(GetHandleSize(self->ob_itself));
+	if (strcmp(name, "data") == 0) {
+		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;
+	}
+	if (strcmp(name, "__members__") == 0)
+		return Py_BuildValue("[ss]", "data", "size");
+
+	return Py_FindMethodInChain(&ResObj_chain, (PyObject *)self, name);
+}
+
+#define ResObj_setattr NULL
+
+PyTypeObject Resource_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0, /*ob_size*/
+	"Resource", /*tp_name*/
+	sizeof(ResourceObject), /*tp_basicsize*/
+	0, /*tp_itemsize*/
+	/* methods */
+	(destructor) ResObj_dealloc, /*tp_dealloc*/
+	0, /*tp_print*/
+	(getattrfunc) ResObj_getattr, /*tp_getattr*/
+	(setattrfunc) ResObj_setattr, /*tp_setattr*/
+};
+
+/* -------------------- End object type Resource -------------------- */
+
+
+static PyObject *Res_InitResources(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = InitResources();
+	{
+		OSErr _err = ResError();
+		if (_err != noErr) return PyMac_Error(_err);
+	}
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Res_RsrcZoneInit(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	RsrcZoneInit();
+	{
+		OSErr _err = ResError();
+		if (_err != noErr) return PyMac_Error(_err);
+	}
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Res_CloseResFile(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short refNum;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = ResError();
+	{
+		OSErr _err = ResError();
+		if (_err != noErr) return PyMac_Error(_err);
+	}
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Res_CurResFile(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	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_CreateResFile(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Str255 fileName;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetStr255, fileName))
+		return NULL;
+	CreateResFile(fileName);
+	{
+		OSErr _err = ResError();
+		if (_err != noErr) return PyMac_Error(_err);
+	}
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Res_OpenResFile(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	Str255 fileName;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetStr255, fileName))
+		return NULL;
+	_rv = OpenResFile(fileName);
+	{
+		OSErr _err = ResError();
+		if (_err != noErr) return PyMac_Error(_err);
+	}
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Res_UseResFile(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short refNum;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	ResType theType;
+	short index;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	ResType theType;
+	short index;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean load;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	ResType theType;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	ResType theType;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	ResType theType;
+	short index;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	ResType theType;
+	short index;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	ResType theType;
+	short theID;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	ResType theType;
+	short theID;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	ResType theType;
+	Str255 name;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	ResType theType;
+	Str255 name;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	ResType theType;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	ResType theType;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short refNum;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean install;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	short refNum;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short refNum;
+	short attrs;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	Str255 fileName;
+	short vRefNum;
+	char permission;
+	if (!PyArg_ParseTuple(_args, "O&hc",
+	                      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_RGetResource(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	ResType theType;
+	short theID;
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      PyMac_GetOSType, &theType,
+	                      &theID))
+		return NULL;
+	_rv = RGetResource(theType,
+	                   theID);
+	{
+		OSErr _err = ResError();
+		if (_err != noErr) return PyMac_Error(_err);
+	}
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Res_HOpenResFile(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	short vRefNum;
+	long dirID;
+	Str255 fileName;
+	char permission;
+	if (!PyArg_ParseTuple(_args, "hlO&c",
+	                      &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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short vRefNum;
+	long dirID;
+	Str255 fileName;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	FSSpec spec;
+	SignedByte permission;
+	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(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	FSSpec spec;
+	OSType creator;
+	OSType fileType;
+	ScriptCode scriptTag;
+	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 PyMethodDef Res_methods[] = {
+	{"InitResources", (PyCFunction)Res_InitResources, 1,
+	 "() -> (short _rv)"},
+	{"RsrcZoneInit", (PyCFunction)Res_RsrcZoneInit, 1,
+	 "() -> None"},
+	{"CloseResFile", (PyCFunction)Res_CloseResFile, 1,
+	 "(short refNum) -> None"},
+	{"ResError", (PyCFunction)Res_ResError, 1,
+	 "() -> (short _rv)"},
+	{"CurResFile", (PyCFunction)Res_CurResFile, 1,
+	 "() -> (short _rv)"},
+	{"CreateResFile", (PyCFunction)Res_CreateResFile, 1,
+	 "(Str255 fileName) -> None"},
+	{"OpenResFile", (PyCFunction)Res_OpenResFile, 1,
+	 "(Str255 fileName) -> (short _rv)"},
+	{"UseResFile", (PyCFunction)Res_UseResFile, 1,
+	 "(short refNum) -> None"},
+	{"CountTypes", (PyCFunction)Res_CountTypes, 1,
+	 "() -> (short _rv)"},
+	{"Count1Types", (PyCFunction)Res_Count1Types, 1,
+	 "() -> (short _rv)"},
+	{"GetIndType", (PyCFunction)Res_GetIndType, 1,
+	 "(short index) -> (ResType theType)"},
+	{"Get1IndType", (PyCFunction)Res_Get1IndType, 1,
+	 "(short index) -> (ResType theType)"},
+	{"SetResLoad", (PyCFunction)Res_SetResLoad, 1,
+	 "(Boolean load) -> None"},
+	{"CountResources", (PyCFunction)Res_CountResources, 1,
+	 "(ResType theType) -> (short _rv)"},
+	{"Count1Resources", (PyCFunction)Res_Count1Resources, 1,
+	 "(ResType theType) -> (short _rv)"},
+	{"GetIndResource", (PyCFunction)Res_GetIndResource, 1,
+	 "(ResType theType, short index) -> (Handle _rv)"},
+	{"Get1IndResource", (PyCFunction)Res_Get1IndResource, 1,
+	 "(ResType theType, short index) -> (Handle _rv)"},
+	{"GetResource", (PyCFunction)Res_GetResource, 1,
+	 "(ResType theType, short theID) -> (Handle _rv)"},
+	{"Get1Resource", (PyCFunction)Res_Get1Resource, 1,
+	 "(ResType theType, short theID) -> (Handle _rv)"},
+	{"GetNamedResource", (PyCFunction)Res_GetNamedResource, 1,
+	 "(ResType theType, Str255 name) -> (Handle _rv)"},
+	{"Get1NamedResource", (PyCFunction)Res_Get1NamedResource, 1,
+	 "(ResType theType, Str255 name) -> (Handle _rv)"},
+	{"UniqueID", (PyCFunction)Res_UniqueID, 1,
+	 "(ResType theType) -> (short _rv)"},
+	{"Unique1ID", (PyCFunction)Res_Unique1ID, 1,
+	 "(ResType theType) -> (short _rv)"},
+	{"UpdateResFile", (PyCFunction)Res_UpdateResFile, 1,
+	 "(short refNum) -> None"},
+	{"SetResPurge", (PyCFunction)Res_SetResPurge, 1,
+	 "(Boolean install) -> None"},
+	{"GetResFileAttrs", (PyCFunction)Res_GetResFileAttrs, 1,
+	 "(short refNum) -> (short _rv)"},
+	{"SetResFileAttrs", (PyCFunction)Res_SetResFileAttrs, 1,
+	 "(short refNum, short attrs) -> None"},
+	{"OpenRFPerm", (PyCFunction)Res_OpenRFPerm, 1,
+	 "(Str255 fileName, short vRefNum, char permission) -> (short _rv)"},
+	{"RGetResource", (PyCFunction)Res_RGetResource, 1,
+	 "(ResType theType, short theID) -> (Handle _rv)"},
+	{"HOpenResFile", (PyCFunction)Res_HOpenResFile, 1,
+	 "(short vRefNum, long dirID, Str255 fileName, char permission) -> (short _rv)"},
+	{"HCreateResFile", (PyCFunction)Res_HCreateResFile, 1,
+	 "(short vRefNum, long dirID, Str255 fileName) -> None"},
+	{"FSpOpenResFile", (PyCFunction)Res_FSpOpenResFile, 1,
+	 "(FSSpec spec, SignedByte permission) -> (short _rv)"},
+	{"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1,
+	 "(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None"},
+	{NULL, NULL, 0}
+};
+
+
+
+
+
+void initRes()
+{
+	PyObject *m;
+	PyObject *d;
+
+
+
+
+
+	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)
+		Py_FatalError("can't initialize Res.Error");
+}
+
+/* ========================= End module Res ========================= */
+