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