_Resmodule.c revision 06d2e1af3579f6a698a84b81dfda0bacb6263f7d 
1
2/* ========================== Module _Res =========================== */
3
4#include "Python.h"
5
6
7
8#include "macglue.h"
9#include "pymactoolbox.h"
10
11/* Macro to test whether a weak-loaded CFM function exists */
12#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
13    	PyErr_SetString(PyExc_NotImplementedError, \
14    	"Not available in this shared library/OS version"); \
15    	return NULL; \
16    }} while(0)
17
18
19#ifdef WITHOUT_FRAMEWORKS
20#include <Resources.h>
21#include <string.h>
22#else
23#include <Carbon/Carbon.h>
24#endif
25
26#ifdef USE_TOOLBOX_OBJECT_GLUE
27extern PyObject *_ResObj_New(Handle);
28extern int _ResObj_Convert(PyObject *, Handle *);
29extern PyObject *_OptResObj_New(Handle);
30extern int _OptResObj_Convert(PyObject *, Handle *);
31#define ResObj_New _ResObj_New
32#define ResObj_Convert _ResObj_Convert
33#define OptResObj_New _OptResObj_New
34#define OptResObj_Convert _OptResObj_Convert
35#endif
36
37/* Function to dispose a resource, with a "normal" calling sequence */
38static void
39PyMac_AutoDisposeHandle(Handle h)
40{
41	DisposeHandle(h);
42}
43
44static PyObject *Res_Error;
45
46/* ---------------------- Object type Resource ---------------------- */
47
48PyTypeObject Resource_Type;
49
50#define ResObj_Check(x) ((x)->ob_type == &Resource_Type)
51
52typedef struct ResourceObject {
53	PyObject_HEAD
54	Handle ob_itself;
55	void (*ob_freeit)(Handle ptr);
56} ResourceObject;
57
58PyObject *ResObj_New(Handle itself)
59{
60	ResourceObject *it;
61	if (itself == NULL) return PyMac_Error(resNotFound);
62	it = PyObject_NEW(ResourceObject, &Resource_Type);
63	if (it == NULL) return NULL;
64	it->ob_itself = itself;
65	it->ob_freeit = NULL;
66	return (PyObject *)it;
67}
68int ResObj_Convert(PyObject *v, Handle *p_itself)
69{
70	if (!ResObj_Check(v))
71	{
72		PyObject *tmp;
73		if ( (tmp=PyObject_CallMethod(v, "as_Resource", "")) )
74		{
75			*p_itself = ((ResourceObject *)tmp)->ob_itself;
76			Py_DECREF(tmp);
77			return 1;
78		}
79		PyErr_Clear();
80	}
81	if (!ResObj_Check(v))
82	{
83		PyErr_SetString(PyExc_TypeError, "Resource required");
84		return 0;
85	}
86	*p_itself = ((ResourceObject *)v)->ob_itself;
87	return 1;
88}
89
90static void ResObj_dealloc(ResourceObject *self)
91{
92	if (self->ob_freeit && self->ob_itself)
93	{
94		self->ob_freeit(self->ob_itself);
95	}
96	self->ob_itself = NULL;
97	PyMem_DEL(self);
98}
99
100static PyObject *ResObj_HomeResFile(ResourceObject *_self, PyObject *_args)
101{
102	PyObject *_res = NULL;
103	short _rv;
104	if (!PyArg_ParseTuple(_args, ""))
105		return NULL;
106	_rv = HomeResFile(_self->ob_itself);
107	{
108		OSErr _err = ResError();
109		if (_err != noErr) return PyMac_Error(_err);
110	}
111	_res = Py_BuildValue("h",
112	                     _rv);
113	return _res;
114}
115
116static PyObject *ResObj_MacLoadResource(ResourceObject *_self, PyObject *_args)
117{
118	PyObject *_res = NULL;
119	if (!PyArg_ParseTuple(_args, ""))
120		return NULL;
121	MacLoadResource(_self->ob_itself);
122	{
123		OSErr _err = ResError();
124		if (_err != noErr) return PyMac_Error(_err);
125	}
126	Py_INCREF(Py_None);
127	_res = Py_None;
128	return _res;
129}
130
131static PyObject *ResObj_ReleaseResource(ResourceObject *_self, PyObject *_args)
132{
133	PyObject *_res = NULL;
134	if (!PyArg_ParseTuple(_args, ""))
135		return NULL;
136	ReleaseResource(_self->ob_itself);
137	{
138		OSErr _err = ResError();
139		if (_err != noErr) return PyMac_Error(_err);
140	}
141	Py_INCREF(Py_None);
142	_res = Py_None;
143	return _res;
144}
145
146static PyObject *ResObj_DetachResource(ResourceObject *_self, PyObject *_args)
147{
148	PyObject *_res = NULL;
149	if (!PyArg_ParseTuple(_args, ""))
150		return NULL;
151	DetachResource(_self->ob_itself);
152	{
153		OSErr _err = ResError();
154		if (_err != noErr) return PyMac_Error(_err);
155	}
156	Py_INCREF(Py_None);
157	_res = Py_None;
158	return _res;
159}
160
161static PyObject *ResObj_GetResAttrs(ResourceObject *_self, PyObject *_args)
162{
163	PyObject *_res = NULL;
164	short _rv;
165	if (!PyArg_ParseTuple(_args, ""))
166		return NULL;
167	_rv = GetResAttrs(_self->ob_itself);
168	{
169		OSErr _err = ResError();
170		if (_err != noErr) return PyMac_Error(_err);
171	}
172	_res = Py_BuildValue("h",
173	                     _rv);
174	return _res;
175}
176
177static PyObject *ResObj_GetResInfo(ResourceObject *_self, PyObject *_args)
178{
179	PyObject *_res = NULL;
180	short theID;
181	ResType theType;
182	Str255 name;
183	if (!PyArg_ParseTuple(_args, ""))
184		return NULL;
185	GetResInfo(_self->ob_itself,
186	           &theID,
187	           &theType,
188	           name);
189	{
190		OSErr _err = ResError();
191		if (_err != noErr) return PyMac_Error(_err);
192	}
193	_res = Py_BuildValue("hO&O&",
194	                     theID,
195	                     PyMac_BuildOSType, theType,
196	                     PyMac_BuildStr255, name);
197	return _res;
198}
199
200static PyObject *ResObj_SetResInfo(ResourceObject *_self, PyObject *_args)
201{
202	PyObject *_res = NULL;
203	short theID;
204	Str255 name;
205	if (!PyArg_ParseTuple(_args, "hO&",
206	                      &theID,
207	                      PyMac_GetStr255, name))
208		return NULL;
209	SetResInfo(_self->ob_itself,
210	           theID,
211	           name);
212	{
213		OSErr _err = ResError();
214		if (_err != noErr) return PyMac_Error(_err);
215	}
216	Py_INCREF(Py_None);
217	_res = Py_None;
218	return _res;
219}
220
221static PyObject *ResObj_AddResource(ResourceObject *_self, PyObject *_args)
222{
223	PyObject *_res = NULL;
224	ResType theType;
225	short theID;
226	Str255 name;
227	if (!PyArg_ParseTuple(_args, "O&hO&",
228	                      PyMac_GetOSType, &theType,
229	                      &theID,
230	                      PyMac_GetStr255, name))
231		return NULL;
232	AddResource(_self->ob_itself,
233	            theType,
234	            theID,
235	            name);
236	{
237		OSErr _err = ResError();
238		if (_err != noErr) return PyMac_Error(_err);
239	}
240	Py_INCREF(Py_None);
241	_res = Py_None;
242	return _res;
243}
244
245static PyObject *ResObj_GetResourceSizeOnDisk(ResourceObject *_self, PyObject *_args)
246{
247	PyObject *_res = NULL;
248	long _rv;
249	if (!PyArg_ParseTuple(_args, ""))
250		return NULL;
251	_rv = GetResourceSizeOnDisk(_self->ob_itself);
252	{
253		OSErr _err = ResError();
254		if (_err != noErr) return PyMac_Error(_err);
255	}
256	_res = Py_BuildValue("l",
257	                     _rv);
258	return _res;
259}
260
261static PyObject *ResObj_GetMaxResourceSize(ResourceObject *_self, PyObject *_args)
262{
263	PyObject *_res = NULL;
264	long _rv;
265	if (!PyArg_ParseTuple(_args, ""))
266		return NULL;
267	_rv = GetMaxResourceSize(_self->ob_itself);
268	{
269		OSErr _err = ResError();
270		if (_err != noErr) return PyMac_Error(_err);
271	}
272	_res = Py_BuildValue("l",
273	                     _rv);
274	return _res;
275}
276
277#if TARGET_API_MAC_OS8
278
279static PyObject *ResObj_RsrcMapEntry(ResourceObject *_self, PyObject *_args)
280{
281	PyObject *_res = NULL;
282	long _rv;
283	if (!PyArg_ParseTuple(_args, ""))
284		return NULL;
285	_rv = RsrcMapEntry(_self->ob_itself);
286	{
287		OSErr _err = ResError();
288		if (_err != noErr) return PyMac_Error(_err);
289	}
290	_res = Py_BuildValue("l",
291	                     _rv);
292	return _res;
293}
294#endif
295
296static PyObject *ResObj_SetResAttrs(ResourceObject *_self, PyObject *_args)
297{
298	PyObject *_res = NULL;
299	short attrs;
300	if (!PyArg_ParseTuple(_args, "h",
301	                      &attrs))
302		return NULL;
303	SetResAttrs(_self->ob_itself,
304	            attrs);
305	{
306		OSErr _err = ResError();
307		if (_err != noErr) return PyMac_Error(_err);
308	}
309	Py_INCREF(Py_None);
310	_res = Py_None;
311	return _res;
312}
313
314static PyObject *ResObj_ChangedResource(ResourceObject *_self, PyObject *_args)
315{
316	PyObject *_res = NULL;
317	if (!PyArg_ParseTuple(_args, ""))
318		return NULL;
319	ChangedResource(_self->ob_itself);
320	{
321		OSErr _err = ResError();
322		if (_err != noErr) return PyMac_Error(_err);
323	}
324	Py_INCREF(Py_None);
325	_res = Py_None;
326	return _res;
327}
328
329static PyObject *ResObj_RemoveResource(ResourceObject *_self, PyObject *_args)
330{
331	PyObject *_res = NULL;
332	if (!PyArg_ParseTuple(_args, ""))
333		return NULL;
334	RemoveResource(_self->ob_itself);
335	{
336		OSErr _err = ResError();
337		if (_err != noErr) return PyMac_Error(_err);
338	}
339	Py_INCREF(Py_None);
340	_res = Py_None;
341	return _res;
342}
343
344static PyObject *ResObj_WriteResource(ResourceObject *_self, PyObject *_args)
345{
346	PyObject *_res = NULL;
347	if (!PyArg_ParseTuple(_args, ""))
348		return NULL;
349	WriteResource(_self->ob_itself);
350	{
351		OSErr _err = ResError();
352		if (_err != noErr) return PyMac_Error(_err);
353	}
354	Py_INCREF(Py_None);
355	_res = Py_None;
356	return _res;
357}
358
359static PyObject *ResObj_SetResourceSize(ResourceObject *_self, PyObject *_args)
360{
361	PyObject *_res = NULL;
362	long newSize;
363	if (!PyArg_ParseTuple(_args, "l",
364	                      &newSize))
365		return NULL;
366	SetResourceSize(_self->ob_itself,
367	                newSize);
368	{
369		OSErr _err = ResError();
370		if (_err != noErr) return PyMac_Error(_err);
371	}
372	Py_INCREF(Py_None);
373	_res = Py_None;
374	return _res;
375}
376
377static PyObject *ResObj_GetNextFOND(ResourceObject *_self, PyObject *_args)
378{
379	PyObject *_res = NULL;
380	Handle _rv;
381	if (!PyArg_ParseTuple(_args, ""))
382		return NULL;
383	_rv = GetNextFOND(_self->ob_itself);
384	{
385		OSErr _err = ResError();
386		if (_err != noErr) return PyMac_Error(_err);
387	}
388	_res = Py_BuildValue("O&",
389	                     ResObj_New, _rv);
390	return _res;
391}
392
393static PyObject *ResObj_as_Control(ResourceObject *_self, PyObject *_args)
394{
395	PyObject *_res = NULL;
396
397	return CtlObj_New((ControlHandle)_self->ob_itself);
398
399}
400
401static PyObject *ResObj_as_Menu(ResourceObject *_self, PyObject *_args)
402{
403	PyObject *_res = NULL;
404
405	return MenuObj_New((MenuHandle)_self->ob_itself);
406
407}
408
409static PyObject *ResObj_LoadResource(ResourceObject *_self, PyObject *_args)
410{
411	PyObject *_res = NULL;
412	if (!PyArg_ParseTuple(_args, ""))
413		return NULL;
414	LoadResource(_self->ob_itself);
415	{
416		OSErr _err = ResError();
417		if (_err != noErr) return PyMac_Error(_err);
418	}
419	Py_INCREF(Py_None);
420	_res = Py_None;
421	return _res;
422}
423
424static PyObject *ResObj_AutoDispose(ResourceObject *_self, PyObject *_args)
425{
426	PyObject *_res = NULL;
427
428	int onoff, old = 0;
429	if (!PyArg_ParseTuple(_args, "i", &onoff))
430		return NULL;
431	if ( _self->ob_freeit )
432		old = 1;
433	if ( onoff )
434		_self->ob_freeit = PyMac_AutoDisposeHandle;
435	else
436		_self->ob_freeit = NULL;
437	return Py_BuildValue("i", old);
438
439}
440
441static PyMethodDef ResObj_methods[] = {
442	{"HomeResFile", (PyCFunction)ResObj_HomeResFile, 1,
443	 "() -> (short _rv)"},
444	{"MacLoadResource", (PyCFunction)ResObj_MacLoadResource, 1,
445	 "() -> None"},
446	{"ReleaseResource", (PyCFunction)ResObj_ReleaseResource, 1,
447	 "() -> None"},
448	{"DetachResource", (PyCFunction)ResObj_DetachResource, 1,
449	 "() -> None"},
450	{"GetResAttrs", (PyCFunction)ResObj_GetResAttrs, 1,
451	 "() -> (short _rv)"},
452	{"GetResInfo", (PyCFunction)ResObj_GetResInfo, 1,
453	 "() -> (short theID, ResType theType, Str255 name)"},
454	{"SetResInfo", (PyCFunction)ResObj_SetResInfo, 1,
455	 "(short theID, Str255 name) -> None"},
456	{"AddResource", (PyCFunction)ResObj_AddResource, 1,
457	 "(ResType theType, short theID, Str255 name) -> None"},
458	{"GetResourceSizeOnDisk", (PyCFunction)ResObj_GetResourceSizeOnDisk, 1,
459	 "() -> (long _rv)"},
460	{"GetMaxResourceSize", (PyCFunction)ResObj_GetMaxResourceSize, 1,
461	 "() -> (long _rv)"},
462
463#if TARGET_API_MAC_OS8
464	{"RsrcMapEntry", (PyCFunction)ResObj_RsrcMapEntry, 1,
465	 "() -> (long _rv)"},
466#endif
467	{"SetResAttrs", (PyCFunction)ResObj_SetResAttrs, 1,
468	 "(short attrs) -> None"},
469	{"ChangedResource", (PyCFunction)ResObj_ChangedResource, 1,
470	 "() -> None"},
471	{"RemoveResource", (PyCFunction)ResObj_RemoveResource, 1,
472	 "() -> None"},
473	{"WriteResource", (PyCFunction)ResObj_WriteResource, 1,
474	 "() -> None"},
475	{"SetResourceSize", (PyCFunction)ResObj_SetResourceSize, 1,
476	 "(long newSize) -> None"},
477	{"GetNextFOND", (PyCFunction)ResObj_GetNextFOND, 1,
478	 "() -> (Handle _rv)"},
479	{"as_Control", (PyCFunction)ResObj_as_Control, 1,
480	 "Return this resource/handle as a Control"},
481	{"as_Menu", (PyCFunction)ResObj_as_Menu, 1,
482	 "Return this resource/handle as a Menu"},
483	{"LoadResource", (PyCFunction)ResObj_LoadResource, 1,
484	 "() -> None"},
485	{"AutoDispose", (PyCFunction)ResObj_AutoDispose, 1,
486	 "(int)->int. Automatically DisposeHandle the object on Python object cleanup"},
487	{NULL, NULL, 0}
488};
489
490PyMethodChain ResObj_chain = { ResObj_methods, NULL };
491
492static PyObject *ResObj_getattr(ResourceObject *self, char *name)
493{
494
495	if (strcmp(name, "size") == 0)
496		return PyInt_FromLong(GetHandleSize(self->ob_itself));
497	if (strcmp(name, "data") == 0) {
498		PyObject *res;
499		char state;
500		state = HGetState(self->ob_itself);
501		HLock(self->ob_itself);
502		res = PyString_FromStringAndSize(
503			*self->ob_itself,
504			GetHandleSize(self->ob_itself));
505		HUnlock(self->ob_itself);
506		HSetState(self->ob_itself, state);
507		return res;
508	}
509	if (strcmp(name, "__members__") == 0)
510		return Py_BuildValue("[ss]", "data", "size");
511
512	return Py_FindMethodInChain(&ResObj_chain, (PyObject *)self, name);
513}
514
515static int
516ResObj_setattr(ResourceObject *self, char *name, PyObject *value)
517{
518	char *data;
519	long size;
520
521	if (strcmp(name, "data") != 0 || value == NULL )
522		return -1;
523	if ( !PyString_Check(value) )
524		return -1;
525	size = PyString_Size(value);
526	data = PyString_AsString(value);
527	/* XXXX Do I need the GetState/SetState calls? */
528	SetHandleSize(self->ob_itself, size);
529	if ( MemError())
530		return -1;
531	HLock(self->ob_itself);
532	memcpy((char *)*self->ob_itself, data, size);
533	HUnlock(self->ob_itself);
534	/* XXXX Should I do the Changed call immedeately? */
535	return 0;
536}
537
538
539#define ResObj_compare NULL
540
541#define ResObj_repr NULL
542
543#define ResObj_hash NULL
544
545PyTypeObject Resource_Type = {
546	PyObject_HEAD_INIT(&PyType_Type)
547	0, /*ob_size*/
548	"Resource", /*tp_name*/
549	sizeof(ResourceObject), /*tp_basicsize*/
550	0, /*tp_itemsize*/
551	/* methods */
552	(destructor) ResObj_dealloc, /*tp_dealloc*/
553	0, /*tp_print*/
554	(getattrfunc) ResObj_getattr, /*tp_getattr*/
555	(setattrfunc) ResObj_setattr, /*tp_setattr*/
556	(cmpfunc) ResObj_compare, /*tp_compare*/
557	(reprfunc) ResObj_repr, /*tp_repr*/
558	(PyNumberMethods *)0, /* tp_as_number */
559	(PySequenceMethods *)0, /* tp_as_sequence */
560	(PyMappingMethods *)0, /* tp_as_mapping */
561	(hashfunc) ResObj_hash, /*tp_hash*/
562};
563
564/* -------------------- End object type Resource -------------------- */
565
566
567#if TARGET_API_MAC_OS8
568
569static PyObject *Res_InitResources(PyObject *_self, PyObject *_args)
570{
571	PyObject *_res = NULL;
572	short _rv;
573	if (!PyArg_ParseTuple(_args, ""))
574		return NULL;
575	_rv = InitResources();
576	{
577		OSErr _err = ResError();
578		if (_err != noErr) return PyMac_Error(_err);
579	}
580	_res = Py_BuildValue("h",
581	                     _rv);
582	return _res;
583}
584#endif
585
586#if TARGET_API_MAC_OS8
587
588static PyObject *Res_RsrcZoneInit(PyObject *_self, PyObject *_args)
589{
590	PyObject *_res = NULL;
591	if (!PyArg_ParseTuple(_args, ""))
592		return NULL;
593	RsrcZoneInit();
594	{
595		OSErr _err = ResError();
596		if (_err != noErr) return PyMac_Error(_err);
597	}
598	Py_INCREF(Py_None);
599	_res = Py_None;
600	return _res;
601}
602#endif
603
604static PyObject *Res_CloseResFile(PyObject *_self, PyObject *_args)
605{
606	PyObject *_res = NULL;
607	short refNum;
608	if (!PyArg_ParseTuple(_args, "h",
609	                      &refNum))
610		return NULL;
611	CloseResFile(refNum);
612	{
613		OSErr _err = ResError();
614		if (_err != noErr) return PyMac_Error(_err);
615	}
616	Py_INCREF(Py_None);
617	_res = Py_None;
618	return _res;
619}
620
621static PyObject *Res_ResError(PyObject *_self, PyObject *_args)
622{
623	PyObject *_res = NULL;
624	OSErr _rv;
625	if (!PyArg_ParseTuple(_args, ""))
626		return NULL;
627	_rv = ResError();
628	{
629		OSErr _err = ResError();
630		if (_err != noErr) return PyMac_Error(_err);
631	}
632	_res = Py_BuildValue("h",
633	                     _rv);
634	return _res;
635}
636
637static PyObject *Res_CurResFile(PyObject *_self, PyObject *_args)
638{
639	PyObject *_res = NULL;
640	short _rv;
641	if (!PyArg_ParseTuple(_args, ""))
642		return NULL;
643	_rv = CurResFile();
644	{
645		OSErr _err = ResError();
646		if (_err != noErr) return PyMac_Error(_err);
647	}
648	_res = Py_BuildValue("h",
649	                     _rv);
650	return _res;
651}
652
653#if TARGET_API_MAC_OS8
654
655static PyObject *Res_CreateResFile(PyObject *_self, PyObject *_args)
656{
657	PyObject *_res = NULL;
658	Str255 fileName;
659	if (!PyArg_ParseTuple(_args, "O&",
660	                      PyMac_GetStr255, fileName))
661		return NULL;
662	CreateResFile(fileName);
663	{
664		OSErr _err = ResError();
665		if (_err != noErr) return PyMac_Error(_err);
666	}
667	Py_INCREF(Py_None);
668	_res = Py_None;
669	return _res;
670}
671#endif
672
673#if TARGET_API_MAC_OS8
674
675static PyObject *Res_OpenResFile(PyObject *_self, PyObject *_args)
676{
677	PyObject *_res = NULL;
678	short _rv;
679	Str255 fileName;
680	if (!PyArg_ParseTuple(_args, "O&",
681	                      PyMac_GetStr255, fileName))
682		return NULL;
683	_rv = OpenResFile(fileName);
684	{
685		OSErr _err = ResError();
686		if (_err != noErr) return PyMac_Error(_err);
687	}
688	_res = Py_BuildValue("h",
689	                     _rv);
690	return _res;
691}
692#endif
693
694static PyObject *Res_UseResFile(PyObject *_self, PyObject *_args)
695{
696	PyObject *_res = NULL;
697	short refNum;
698	if (!PyArg_ParseTuple(_args, "h",
699	                      &refNum))
700		return NULL;
701	UseResFile(refNum);
702	{
703		OSErr _err = ResError();
704		if (_err != noErr) return PyMac_Error(_err);
705	}
706	Py_INCREF(Py_None);
707	_res = Py_None;
708	return _res;
709}
710
711static PyObject *Res_CountTypes(PyObject *_self, PyObject *_args)
712{
713	PyObject *_res = NULL;
714	short _rv;
715	if (!PyArg_ParseTuple(_args, ""))
716		return NULL;
717	_rv = CountTypes();
718	{
719		OSErr _err = ResError();
720		if (_err != noErr) return PyMac_Error(_err);
721	}
722	_res = Py_BuildValue("h",
723	                     _rv);
724	return _res;
725}
726
727static PyObject *Res_Count1Types(PyObject *_self, PyObject *_args)
728{
729	PyObject *_res = NULL;
730	short _rv;
731	if (!PyArg_ParseTuple(_args, ""))
732		return NULL;
733	_rv = Count1Types();
734	{
735		OSErr _err = ResError();
736		if (_err != noErr) return PyMac_Error(_err);
737	}
738	_res = Py_BuildValue("h",
739	                     _rv);
740	return _res;
741}
742
743static PyObject *Res_GetIndType(PyObject *_self, PyObject *_args)
744{
745	PyObject *_res = NULL;
746	ResType theType;
747	short index;
748	if (!PyArg_ParseTuple(_args, "h",
749	                      &index))
750		return NULL;
751	GetIndType(&theType,
752	           index);
753	{
754		OSErr _err = ResError();
755		if (_err != noErr) return PyMac_Error(_err);
756	}
757	_res = Py_BuildValue("O&",
758	                     PyMac_BuildOSType, theType);
759	return _res;
760}
761
762static PyObject *Res_Get1IndType(PyObject *_self, PyObject *_args)
763{
764	PyObject *_res = NULL;
765	ResType theType;
766	short index;
767	if (!PyArg_ParseTuple(_args, "h",
768	                      &index))
769		return NULL;
770	Get1IndType(&theType,
771	            index);
772	{
773		OSErr _err = ResError();
774		if (_err != noErr) return PyMac_Error(_err);
775	}
776	_res = Py_BuildValue("O&",
777	                     PyMac_BuildOSType, theType);
778	return _res;
779}
780
781static PyObject *Res_SetResLoad(PyObject *_self, PyObject *_args)
782{
783	PyObject *_res = NULL;
784	Boolean load;
785	if (!PyArg_ParseTuple(_args, "b",
786	                      &load))
787		return NULL;
788	SetResLoad(load);
789	{
790		OSErr _err = ResError();
791		if (_err != noErr) return PyMac_Error(_err);
792	}
793	Py_INCREF(Py_None);
794	_res = Py_None;
795	return _res;
796}
797
798static PyObject *Res_CountResources(PyObject *_self, PyObject *_args)
799{
800	PyObject *_res = NULL;
801	short _rv;
802	ResType theType;
803	if (!PyArg_ParseTuple(_args, "O&",
804	                      PyMac_GetOSType, &theType))
805		return NULL;
806	_rv = CountResources(theType);
807	{
808		OSErr _err = ResError();
809		if (_err != noErr) return PyMac_Error(_err);
810	}
811	_res = Py_BuildValue("h",
812	                     _rv);
813	return _res;
814}
815
816static PyObject *Res_Count1Resources(PyObject *_self, PyObject *_args)
817{
818	PyObject *_res = NULL;
819	short _rv;
820	ResType theType;
821	if (!PyArg_ParseTuple(_args, "O&",
822	                      PyMac_GetOSType, &theType))
823		return NULL;
824	_rv = Count1Resources(theType);
825	{
826		OSErr _err = ResError();
827		if (_err != noErr) return PyMac_Error(_err);
828	}
829	_res = Py_BuildValue("h",
830	                     _rv);
831	return _res;
832}
833
834static PyObject *Res_GetIndResource(PyObject *_self, PyObject *_args)
835{
836	PyObject *_res = NULL;
837	Handle _rv;
838	ResType theType;
839	short index;
840	if (!PyArg_ParseTuple(_args, "O&h",
841	                      PyMac_GetOSType, &theType,
842	                      &index))
843		return NULL;
844	_rv = GetIndResource(theType,
845	                     index);
846	{
847		OSErr _err = ResError();
848		if (_err != noErr) return PyMac_Error(_err);
849	}
850	_res = Py_BuildValue("O&",
851	                     ResObj_New, _rv);
852	return _res;
853}
854
855static PyObject *Res_Get1IndResource(PyObject *_self, PyObject *_args)
856{
857	PyObject *_res = NULL;
858	Handle _rv;
859	ResType theType;
860	short index;
861	if (!PyArg_ParseTuple(_args, "O&h",
862	                      PyMac_GetOSType, &theType,
863	                      &index))
864		return NULL;
865	_rv = Get1IndResource(theType,
866	                      index);
867	{
868		OSErr _err = ResError();
869		if (_err != noErr) return PyMac_Error(_err);
870	}
871	_res = Py_BuildValue("O&",
872	                     ResObj_New, _rv);
873	return _res;
874}
875
876static PyObject *Res_GetResource(PyObject *_self, PyObject *_args)
877{
878	PyObject *_res = NULL;
879	Handle _rv;
880	ResType theType;
881	short theID;
882	if (!PyArg_ParseTuple(_args, "O&h",
883	                      PyMac_GetOSType, &theType,
884	                      &theID))
885		return NULL;
886	_rv = GetResource(theType,
887	                  theID);
888	{
889		OSErr _err = ResError();
890		if (_err != noErr) return PyMac_Error(_err);
891	}
892	_res = Py_BuildValue("O&",
893	                     ResObj_New, _rv);
894	return _res;
895}
896
897static PyObject *Res_Get1Resource(PyObject *_self, PyObject *_args)
898{
899	PyObject *_res = NULL;
900	Handle _rv;
901	ResType theType;
902	short theID;
903	if (!PyArg_ParseTuple(_args, "O&h",
904	                      PyMac_GetOSType, &theType,
905	                      &theID))
906		return NULL;
907	_rv = Get1Resource(theType,
908	                   theID);
909	{
910		OSErr _err = ResError();
911		if (_err != noErr) return PyMac_Error(_err);
912	}
913	_res = Py_BuildValue("O&",
914	                     ResObj_New, _rv);
915	return _res;
916}
917
918static PyObject *Res_GetNamedResource(PyObject *_self, PyObject *_args)
919{
920	PyObject *_res = NULL;
921	Handle _rv;
922	ResType theType;
923	Str255 name;
924	if (!PyArg_ParseTuple(_args, "O&O&",
925	                      PyMac_GetOSType, &theType,
926	                      PyMac_GetStr255, name))
927		return NULL;
928	_rv = GetNamedResource(theType,
929	                       name);
930	{
931		OSErr _err = ResError();
932		if (_err != noErr) return PyMac_Error(_err);
933	}
934	_res = Py_BuildValue("O&",
935	                     ResObj_New, _rv);
936	return _res;
937}
938
939static PyObject *Res_Get1NamedResource(PyObject *_self, PyObject *_args)
940{
941	PyObject *_res = NULL;
942	Handle _rv;
943	ResType theType;
944	Str255 name;
945	if (!PyArg_ParseTuple(_args, "O&O&",
946	                      PyMac_GetOSType, &theType,
947	                      PyMac_GetStr255, name))
948		return NULL;
949	_rv = Get1NamedResource(theType,
950	                        name);
951	{
952		OSErr _err = ResError();
953		if (_err != noErr) return PyMac_Error(_err);
954	}
955	_res = Py_BuildValue("O&",
956	                     ResObj_New, _rv);
957	return _res;
958}
959
960static PyObject *Res_UniqueID(PyObject *_self, PyObject *_args)
961{
962	PyObject *_res = NULL;
963	short _rv;
964	ResType theType;
965	if (!PyArg_ParseTuple(_args, "O&",
966	                      PyMac_GetOSType, &theType))
967		return NULL;
968	_rv = UniqueID(theType);
969	{
970		OSErr _err = ResError();
971		if (_err != noErr) return PyMac_Error(_err);
972	}
973	_res = Py_BuildValue("h",
974	                     _rv);
975	return _res;
976}
977
978static PyObject *Res_Unique1ID(PyObject *_self, PyObject *_args)
979{
980	PyObject *_res = NULL;
981	short _rv;
982	ResType theType;
983	if (!PyArg_ParseTuple(_args, "O&",
984	                      PyMac_GetOSType, &theType))
985		return NULL;
986	_rv = Unique1ID(theType);
987	{
988		OSErr _err = ResError();
989		if (_err != noErr) return PyMac_Error(_err);
990	}
991	_res = Py_BuildValue("h",
992	                     _rv);
993	return _res;
994}
995
996static PyObject *Res_UpdateResFile(PyObject *_self, PyObject *_args)
997{
998	PyObject *_res = NULL;
999	short refNum;
1000	if (!PyArg_ParseTuple(_args, "h",
1001	                      &refNum))
1002		return NULL;
1003	UpdateResFile(refNum);
1004	{
1005		OSErr _err = ResError();
1006		if (_err != noErr) return PyMac_Error(_err);
1007	}
1008	Py_INCREF(Py_None);
1009	_res = Py_None;
1010	return _res;
1011}
1012
1013static PyObject *Res_SetResPurge(PyObject *_self, PyObject *_args)
1014{
1015	PyObject *_res = NULL;
1016	Boolean install;
1017	if (!PyArg_ParseTuple(_args, "b",
1018	                      &install))
1019		return NULL;
1020	SetResPurge(install);
1021	{
1022		OSErr _err = ResError();
1023		if (_err != noErr) return PyMac_Error(_err);
1024	}
1025	Py_INCREF(Py_None);
1026	_res = Py_None;
1027	return _res;
1028}
1029
1030static PyObject *Res_GetResFileAttrs(PyObject *_self, PyObject *_args)
1031{
1032	PyObject *_res = NULL;
1033	short _rv;
1034	short refNum;
1035	if (!PyArg_ParseTuple(_args, "h",
1036	                      &refNum))
1037		return NULL;
1038	_rv = GetResFileAttrs(refNum);
1039	{
1040		OSErr _err = ResError();
1041		if (_err != noErr) return PyMac_Error(_err);
1042	}
1043	_res = Py_BuildValue("h",
1044	                     _rv);
1045	return _res;
1046}
1047
1048static PyObject *Res_SetResFileAttrs(PyObject *_self, PyObject *_args)
1049{
1050	PyObject *_res = NULL;
1051	short refNum;
1052	short attrs;
1053	if (!PyArg_ParseTuple(_args, "hh",
1054	                      &refNum,
1055	                      &attrs))
1056		return NULL;
1057	SetResFileAttrs(refNum,
1058	                attrs);
1059	{
1060		OSErr _err = ResError();
1061		if (_err != noErr) return PyMac_Error(_err);
1062	}
1063	Py_INCREF(Py_None);
1064	_res = Py_None;
1065	return _res;
1066}
1067
1068static PyObject *Res_OpenRFPerm(PyObject *_self, PyObject *_args)
1069{
1070	PyObject *_res = NULL;
1071	short _rv;
1072	Str255 fileName;
1073	short vRefNum;
1074	SignedByte permission;
1075	if (!PyArg_ParseTuple(_args, "O&hb",
1076	                      PyMac_GetStr255, fileName,
1077	                      &vRefNum,
1078	                      &permission))
1079		return NULL;
1080	_rv = OpenRFPerm(fileName,
1081	                 vRefNum,
1082	                 permission);
1083	{
1084		OSErr _err = ResError();
1085		if (_err != noErr) return PyMac_Error(_err);
1086	}
1087	_res = Py_BuildValue("h",
1088	                     _rv);
1089	return _res;
1090}
1091
1092#if TARGET_API_MAC_OS8
1093
1094static PyObject *Res_RGetResource(PyObject *_self, PyObject *_args)
1095{
1096	PyObject *_res = NULL;
1097	Handle _rv;
1098	ResType theType;
1099	short theID;
1100	if (!PyArg_ParseTuple(_args, "O&h",
1101	                      PyMac_GetOSType, &theType,
1102	                      &theID))
1103		return NULL;
1104	_rv = RGetResource(theType,
1105	                   theID);
1106	{
1107		OSErr _err = ResError();
1108		if (_err != noErr) return PyMac_Error(_err);
1109	}
1110	_res = Py_BuildValue("O&",
1111	                     ResObj_New, _rv);
1112	return _res;
1113}
1114#endif
1115
1116static PyObject *Res_HOpenResFile(PyObject *_self, PyObject *_args)
1117{
1118	PyObject *_res = NULL;
1119	short _rv;
1120	short vRefNum;
1121	long dirID;
1122	Str255 fileName;
1123	SignedByte permission;
1124	if (!PyArg_ParseTuple(_args, "hlO&b",
1125	                      &vRefNum,
1126	                      &dirID,
1127	                      PyMac_GetStr255, fileName,
1128	                      &permission))
1129		return NULL;
1130	_rv = HOpenResFile(vRefNum,
1131	                   dirID,
1132	                   fileName,
1133	                   permission);
1134	{
1135		OSErr _err = ResError();
1136		if (_err != noErr) return PyMac_Error(_err);
1137	}
1138	_res = Py_BuildValue("h",
1139	                     _rv);
1140	return _res;
1141}
1142
1143static PyObject *Res_HCreateResFile(PyObject *_self, PyObject *_args)
1144{
1145	PyObject *_res = NULL;
1146	short vRefNum;
1147	long dirID;
1148	Str255 fileName;
1149	if (!PyArg_ParseTuple(_args, "hlO&",
1150	                      &vRefNum,
1151	                      &dirID,
1152	                      PyMac_GetStr255, fileName))
1153		return NULL;
1154	HCreateResFile(vRefNum,
1155	               dirID,
1156	               fileName);
1157	{
1158		OSErr _err = ResError();
1159		if (_err != noErr) return PyMac_Error(_err);
1160	}
1161	Py_INCREF(Py_None);
1162	_res = Py_None;
1163	return _res;
1164}
1165
1166static PyObject *Res_FSpOpenResFile(PyObject *_self, PyObject *_args)
1167{
1168	PyObject *_res = NULL;
1169	short _rv;
1170	FSSpec spec;
1171	SignedByte permission;
1172	if (!PyArg_ParseTuple(_args, "O&b",
1173	                      PyMac_GetFSSpec, &spec,
1174	                      &permission))
1175		return NULL;
1176	_rv = FSpOpenResFile(&spec,
1177	                     permission);
1178	{
1179		OSErr _err = ResError();
1180		if (_err != noErr) return PyMac_Error(_err);
1181	}
1182	_res = Py_BuildValue("h",
1183	                     _rv);
1184	return _res;
1185}
1186
1187static PyObject *Res_FSpCreateResFile(PyObject *_self, PyObject *_args)
1188{
1189	PyObject *_res = NULL;
1190	FSSpec spec;
1191	OSType creator;
1192	OSType fileType;
1193	ScriptCode scriptTag;
1194	if (!PyArg_ParseTuple(_args, "O&O&O&h",
1195	                      PyMac_GetFSSpec, &spec,
1196	                      PyMac_GetOSType, &creator,
1197	                      PyMac_GetOSType, &fileType,
1198	                      &scriptTag))
1199		return NULL;
1200	FSpCreateResFile(&spec,
1201	                 creator,
1202	                 fileType,
1203	                 scriptTag);
1204	{
1205		OSErr _err = ResError();
1206		if (_err != noErr) return PyMac_Error(_err);
1207	}
1208	Py_INCREF(Py_None);
1209	_res = Py_None;
1210	return _res;
1211}
1212
1213#if TARGET_API_MAC_CARBON
1214
1215static PyObject *Res_InsertResourceFile(PyObject *_self, PyObject *_args)
1216{
1217	PyObject *_res = NULL;
1218	OSErr _rv;
1219	SInt16 refNum;
1220	RsrcChainLocation where;
1221	if (!PyArg_ParseTuple(_args, "hh",
1222	                      &refNum,
1223	                      &where))
1224		return NULL;
1225	_rv = InsertResourceFile(refNum,
1226	                         where);
1227	{
1228		OSErr _err = ResError();
1229		if (_err != noErr) return PyMac_Error(_err);
1230	}
1231	_res = Py_BuildValue("h",
1232	                     _rv);
1233	return _res;
1234}
1235#endif
1236
1237#if TARGET_API_MAC_CARBON
1238
1239static PyObject *Res_DetachResourceFile(PyObject *_self, PyObject *_args)
1240{
1241	PyObject *_res = NULL;
1242	OSErr _rv;
1243	SInt16 refNum;
1244	if (!PyArg_ParseTuple(_args, "h",
1245	                      &refNum))
1246		return NULL;
1247	_rv = DetachResourceFile(refNum);
1248	{
1249		OSErr _err = ResError();
1250		if (_err != noErr) return PyMac_Error(_err);
1251	}
1252	_res = Py_BuildValue("h",
1253	                     _rv);
1254	return _res;
1255}
1256#endif
1257
1258#if TARGET_API_MAC_CARBON
1259
1260static PyObject *Res_FSpResourceFileAlreadyOpen(PyObject *_self, PyObject *_args)
1261{
1262	PyObject *_res = NULL;
1263	Boolean _rv;
1264	FSSpec resourceFile;
1265	Boolean inChain;
1266	SInt16 refNum;
1267	if (!PyArg_ParseTuple(_args, "O&",
1268	                      PyMac_GetFSSpec, &resourceFile))
1269		return NULL;
1270	_rv = FSpResourceFileAlreadyOpen(&resourceFile,
1271	                                 &inChain,
1272	                                 &refNum);
1273	{
1274		OSErr _err = ResError();
1275		if (_err != noErr) return PyMac_Error(_err);
1276	}
1277	_res = Py_BuildValue("bbh",
1278	                     _rv,
1279	                     inChain,
1280	                     refNum);
1281	return _res;
1282}
1283#endif
1284
1285#if TARGET_API_MAC_CARBON
1286
1287static PyObject *Res_FSpOpenOrphanResFile(PyObject *_self, PyObject *_args)
1288{
1289	PyObject *_res = NULL;
1290	OSErr _rv;
1291	FSSpec spec;
1292	SignedByte permission;
1293	SInt16 refNum;
1294	if (!PyArg_ParseTuple(_args, "O&b",
1295	                      PyMac_GetFSSpec, &spec,
1296	                      &permission))
1297		return NULL;
1298	_rv = FSpOpenOrphanResFile(&spec,
1299	                           permission,
1300	                           &refNum);
1301	{
1302		OSErr _err = ResError();
1303		if (_err != noErr) return PyMac_Error(_err);
1304	}
1305	_res = Py_BuildValue("hh",
1306	                     _rv,
1307	                     refNum);
1308	return _res;
1309}
1310#endif
1311
1312#if TARGET_API_MAC_CARBON
1313
1314static PyObject *Res_GetTopResourceFile(PyObject *_self, PyObject *_args)
1315{
1316	PyObject *_res = NULL;
1317	OSErr _rv;
1318	SInt16 refNum;
1319	if (!PyArg_ParseTuple(_args, ""))
1320		return NULL;
1321	_rv = GetTopResourceFile(&refNum);
1322	{
1323		OSErr _err = ResError();
1324		if (_err != noErr) return PyMac_Error(_err);
1325	}
1326	_res = Py_BuildValue("hh",
1327	                     _rv,
1328	                     refNum);
1329	return _res;
1330}
1331#endif
1332
1333#if TARGET_API_MAC_CARBON
1334
1335static PyObject *Res_GetNextResourceFile(PyObject *_self, PyObject *_args)
1336{
1337	PyObject *_res = NULL;
1338	OSErr _rv;
1339	SInt16 curRefNum;
1340	SInt16 nextRefNum;
1341	if (!PyArg_ParseTuple(_args, "h",
1342	                      &curRefNum))
1343		return NULL;
1344	_rv = GetNextResourceFile(curRefNum,
1345	                          &nextRefNum);
1346	{
1347		OSErr _err = ResError();
1348		if (_err != noErr) return PyMac_Error(_err);
1349	}
1350	_res = Py_BuildValue("hh",
1351	                     _rv,
1352	                     nextRefNum);
1353	return _res;
1354}
1355#endif
1356
1357static PyObject *Res_Resource(PyObject *_self, PyObject *_args)
1358{
1359	PyObject *_res = NULL;
1360
1361	char *buf;
1362	int len;
1363	Handle h;
1364
1365	if (!PyArg_ParseTuple(_args, "s#", &buf, &len))
1366		return NULL;
1367	h = NewHandle(len);
1368	if ( h == NULL ) {
1369		PyErr_NoMemory();
1370		return NULL;
1371	}
1372	HLock(h);
1373	memcpy(*h, buf, len);
1374	HUnlock(h);
1375	return ResObj_New(h);
1376
1377}
1378
1379static PyObject *Res_Handle(PyObject *_self, PyObject *_args)
1380{
1381	PyObject *_res = NULL;
1382
1383	char *buf;
1384	int len;
1385	Handle h;
1386	ResourceObject *rv;
1387
1388	if (!PyArg_ParseTuple(_args, "s#", &buf, &len))
1389		return NULL;
1390	h = NewHandle(len);
1391	if ( h == NULL ) {
1392		PyErr_NoMemory();
1393		return NULL;
1394	}
1395	HLock(h);
1396	memcpy(*h, buf, len);
1397	HUnlock(h);
1398	rv = (ResourceObject *)ResObj_New(h);
1399	rv->ob_freeit = PyMac_AutoDisposeHandle;
1400	return (PyObject *)rv;
1401
1402}
1403
1404static PyMethodDef Res_methods[] = {
1405
1406#if TARGET_API_MAC_OS8
1407	{"InitResources", (PyCFunction)Res_InitResources, 1,
1408	 "() -> (short _rv)"},
1409#endif
1410
1411#if TARGET_API_MAC_OS8
1412	{"RsrcZoneInit", (PyCFunction)Res_RsrcZoneInit, 1,
1413	 "() -> None"},
1414#endif
1415	{"CloseResFile", (PyCFunction)Res_CloseResFile, 1,
1416	 "(short refNum) -> None"},
1417	{"ResError", (PyCFunction)Res_ResError, 1,
1418	 "() -> (OSErr _rv)"},
1419	{"CurResFile", (PyCFunction)Res_CurResFile, 1,
1420	 "() -> (short _rv)"},
1421
1422#if TARGET_API_MAC_OS8
1423	{"CreateResFile", (PyCFunction)Res_CreateResFile, 1,
1424	 "(Str255 fileName) -> None"},
1425#endif
1426
1427#if TARGET_API_MAC_OS8
1428	{"OpenResFile", (PyCFunction)Res_OpenResFile, 1,
1429	 "(Str255 fileName) -> (short _rv)"},
1430#endif
1431	{"UseResFile", (PyCFunction)Res_UseResFile, 1,
1432	 "(short refNum) -> None"},
1433	{"CountTypes", (PyCFunction)Res_CountTypes, 1,
1434	 "() -> (short _rv)"},
1435	{"Count1Types", (PyCFunction)Res_Count1Types, 1,
1436	 "() -> (short _rv)"},
1437	{"GetIndType", (PyCFunction)Res_GetIndType, 1,
1438	 "(short index) -> (ResType theType)"},
1439	{"Get1IndType", (PyCFunction)Res_Get1IndType, 1,
1440	 "(short index) -> (ResType theType)"},
1441	{"SetResLoad", (PyCFunction)Res_SetResLoad, 1,
1442	 "(Boolean load) -> None"},
1443	{"CountResources", (PyCFunction)Res_CountResources, 1,
1444	 "(ResType theType) -> (short _rv)"},
1445	{"Count1Resources", (PyCFunction)Res_Count1Resources, 1,
1446	 "(ResType theType) -> (short _rv)"},
1447	{"GetIndResource", (PyCFunction)Res_GetIndResource, 1,
1448	 "(ResType theType, short index) -> (Handle _rv)"},
1449	{"Get1IndResource", (PyCFunction)Res_Get1IndResource, 1,
1450	 "(ResType theType, short index) -> (Handle _rv)"},
1451	{"GetResource", (PyCFunction)Res_GetResource, 1,
1452	 "(ResType theType, short theID) -> (Handle _rv)"},
1453	{"Get1Resource", (PyCFunction)Res_Get1Resource, 1,
1454	 "(ResType theType, short theID) -> (Handle _rv)"},
1455	{"GetNamedResource", (PyCFunction)Res_GetNamedResource, 1,
1456	 "(ResType theType, Str255 name) -> (Handle _rv)"},
1457	{"Get1NamedResource", (PyCFunction)Res_Get1NamedResource, 1,
1458	 "(ResType theType, Str255 name) -> (Handle _rv)"},
1459	{"UniqueID", (PyCFunction)Res_UniqueID, 1,
1460	 "(ResType theType) -> (short _rv)"},
1461	{"Unique1ID", (PyCFunction)Res_Unique1ID, 1,
1462	 "(ResType theType) -> (short _rv)"},
1463	{"UpdateResFile", (PyCFunction)Res_UpdateResFile, 1,
1464	 "(short refNum) -> None"},
1465	{"SetResPurge", (PyCFunction)Res_SetResPurge, 1,
1466	 "(Boolean install) -> None"},
1467	{"GetResFileAttrs", (PyCFunction)Res_GetResFileAttrs, 1,
1468	 "(short refNum) -> (short _rv)"},
1469	{"SetResFileAttrs", (PyCFunction)Res_SetResFileAttrs, 1,
1470	 "(short refNum, short attrs) -> None"},
1471	{"OpenRFPerm", (PyCFunction)Res_OpenRFPerm, 1,
1472	 "(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)"},
1473
1474#if TARGET_API_MAC_OS8
1475	{"RGetResource", (PyCFunction)Res_RGetResource, 1,
1476	 "(ResType theType, short theID) -> (Handle _rv)"},
1477#endif
1478	{"HOpenResFile", (PyCFunction)Res_HOpenResFile, 1,
1479	 "(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)"},
1480	{"HCreateResFile", (PyCFunction)Res_HCreateResFile, 1,
1481	 "(short vRefNum, long dirID, Str255 fileName) -> None"},
1482	{"FSpOpenResFile", (PyCFunction)Res_FSpOpenResFile, 1,
1483	 "(FSSpec spec, SignedByte permission) -> (short _rv)"},
1484	{"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1,
1485	 "(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None"},
1486
1487#if TARGET_API_MAC_CARBON
1488	{"InsertResourceFile", (PyCFunction)Res_InsertResourceFile, 1,
1489	 "(SInt16 refNum, RsrcChainLocation where) -> (OSErr _rv)"},
1490#endif
1491
1492#if TARGET_API_MAC_CARBON
1493	{"DetachResourceFile", (PyCFunction)Res_DetachResourceFile, 1,
1494	 "(SInt16 refNum) -> (OSErr _rv)"},
1495#endif
1496
1497#if TARGET_API_MAC_CARBON
1498	{"FSpResourceFileAlreadyOpen", (PyCFunction)Res_FSpResourceFileAlreadyOpen, 1,
1499	 "(FSSpec resourceFile) -> (Boolean _rv, Boolean inChain, SInt16 refNum)"},
1500#endif
1501
1502#if TARGET_API_MAC_CARBON
1503	{"FSpOpenOrphanResFile", (PyCFunction)Res_FSpOpenOrphanResFile, 1,
1504	 "(FSSpec spec, SignedByte permission) -> (OSErr _rv, SInt16 refNum)"},
1505#endif
1506
1507#if TARGET_API_MAC_CARBON
1508	{"GetTopResourceFile", (PyCFunction)Res_GetTopResourceFile, 1,
1509	 "() -> (OSErr _rv, SInt16 refNum)"},
1510#endif
1511
1512#if TARGET_API_MAC_CARBON
1513	{"GetNextResourceFile", (PyCFunction)Res_GetNextResourceFile, 1,
1514	 "(SInt16 curRefNum) -> (OSErr _rv, SInt16 nextRefNum)"},
1515#endif
1516	{"Resource", (PyCFunction)Res_Resource, 1,
1517	 "Convert a string to a resource object.\n\nThe created resource object is actually just a handle,\napply AddResource() to write it to a resource file.\nSee also the Handle() docstring.\n"},
1518	{"Handle", (PyCFunction)Res_Handle, 1,
1519	 "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"},
1520	{NULL, NULL, 0}
1521};
1522
1523
1524
1525
1526/* Alternative version of ResObj_New, which returns None for null argument */
1527PyObject *OptResObj_New(Handle itself)
1528{
1529	if (itself == NULL) {
1530		Py_INCREF(Py_None);
1531		return Py_None;
1532	}
1533	return ResObj_New(itself);
1534}
1535
1536OptResObj_Convert(PyObject *v, Handle *p_itself)
1537{
1538	PyObject *tmp;
1539
1540	if ( v == Py_None ) {
1541		*p_itself = NULL;
1542		return 1;
1543	}
1544	if (ResObj_Check(v))
1545	{
1546		*p_itself = ((ResourceObject *)v)->ob_itself;
1547		return 1;
1548	}
1549	/* If it isn't a resource yet see whether it is convertible */
1550	if ( (tmp=PyObject_CallMethod(v, "as_Resource", "")) ) {
1551		*p_itself = ((ResourceObject *)tmp)->ob_itself;
1552		Py_DECREF(tmp);
1553		return 1;
1554	}
1555	PyErr_Clear();
1556	PyErr_SetString(PyExc_TypeError, "Resource required");
1557	return 0;
1558}
1559
1560
1561void init_Res(void)
1562{
1563	PyObject *m;
1564	PyObject *d;
1565
1566
1567
1568		PyMac_INIT_TOOLBOX_OBJECT_NEW(Handle, ResObj_New);
1569		PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Handle, ResObj_Convert);
1570		PyMac_INIT_TOOLBOX_OBJECT_NEW(Handle, OptResObj_New);
1571		PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Handle, OptResObj_Convert);
1572
1573
1574	m = Py_InitModule("_Res", Res_methods);
1575	d = PyModule_GetDict(m);
1576	Res_Error = PyMac_GetOSErrException();
1577	if (Res_Error == NULL ||
1578	    PyDict_SetItemString(d, "Error", Res_Error) != 0)
1579		return;
1580	Resource_Type.ob_type = &PyType_Type;
1581	Py_INCREF(&Resource_Type);
1582	if (PyDict_SetItemString(d, "ResourceType", (PyObject *)&Resource_Type) != 0)
1583		Py_FatalError("can't initialize ResourceType");
1584}
1585
1586/* ======================== End module _Res ========================= */
1587
1588