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