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
20 extern PyObject *_ResObj_New(Handle);
21 extern int _ResObj_Convert(PyObject *, Handle *);
22 extern PyObject *_OptResObj_New(Handle);
23 extern 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 */
31 static void
PyMac_AutoDisposeHandle(Handle h)32 PyMac_AutoDisposeHandle(Handle h)
33 {
34     DisposeHandle(h);
35 }
36 
37 static PyObject *Res_Error;
38 
39 /* ---------------------- Object type Resource ---------------------- */
40 
41 PyTypeObject Resource_Type;
42 
43 #define ResObj_Check(x) ((x)->ob_type == &Resource_Type || PyObject_TypeCheck((x), &Resource_Type))
44 
45 typedef struct ResourceObject {
46     PyObject_HEAD
47     Handle ob_itself;
48     void (*ob_freeit)(Handle ptr);
49 } ResourceObject;
50 
ResObj_New(Handle itself)51 PyObject *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 
ResObj_Convert(PyObject * v,Handle * p_itself)62 int 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 
ResObj_dealloc(ResourceObject * self)84 static 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 
ResObj_HomeResFile(ResourceObject * _self,PyObject * _args)94 static 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 
ResObj_MacLoadResource(ResourceObject * _self,PyObject * _args)113 static 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 
ResObj_ReleaseResource(ResourceObject * _self,PyObject * _args)131 static 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 
ResObj_DetachResource(ResourceObject * _self,PyObject * _args)149 static 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 
ResObj_GetResAttrs(ResourceObject * _self,PyObject * _args)167 static 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 
ResObj_GetResInfo(ResourceObject * _self,PyObject * _args)186 static 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 
ResObj_SetResInfo(ResourceObject * _self,PyObject * _args)212 static 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 
ResObj_AddResource(ResourceObject * _self,PyObject * _args)236 static 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 
ResObj_GetResourceSizeOnDisk(ResourceObject * _self,PyObject * _args)263 static 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 
ResObj_GetMaxResourceSize(ResourceObject * _self,PyObject * _args)282 static 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 
ResObj_SetResAttrs(ResourceObject * _self,PyObject * _args)301 static 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 
ResObj_ChangedResource(ResourceObject * _self,PyObject * _args)322 static 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 
ResObj_RemoveResource(ResourceObject * _self,PyObject * _args)340 static 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 
ResObj_WriteResource(ResourceObject * _self,PyObject * _args)358 static 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 
ResObj_SetResourceSize(ResourceObject * _self,PyObject * _args)376 static 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 
ResObj_GetNextFOND(ResourceObject * _self,PyObject * _args)397 static 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__
ResObj_as_Control(ResourceObject * _self,PyObject * _args)417 static 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 
ResObj_as_Menu(ResourceObject * _self,PyObject * _args)426 static 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 
ResObj_LoadResource(ResourceObject * _self,PyObject * _args)436 static 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 
ResObj_AutoDispose(ResourceObject * _self,PyObject * _args)454 static 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 
472 static 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 
ResObj_get_data(ResourceObject * self,void * closure)518 static 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 
ResObj_set_data(ResourceObject * self,PyObject * v,void * closure)535 static 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 
ResObj_get_size(ResourceObject * self,void * closure)560 static 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 
567 static 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
ResObj_tp_init(PyObject * _self,PyObject * _args,PyObject * _kwds)579 static 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 
ResObj_tp_new(PyTypeObject * type,PyObject * _args,PyObject * _kwds)610 static 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 
622 PyTypeObject 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 
Res_CloseResFile(PyObject * _self,PyObject * _args)669 static 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 
Res_ResError(PyObject * _self,PyObject * _args)689 static 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 
Res_CurResFile(PyObject * _self,PyObject * _args)705 static 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 
Res_UseResFile(PyObject * _self,PyObject * _args)724 static 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 
Res_CountTypes(PyObject * _self,PyObject * _args)744 static 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 
Res_Count1Types(PyObject * _self,PyObject * _args)763 static 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 
Res_GetIndType(PyObject * _self,PyObject * _args)782 static 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 
Res_Get1IndType(PyObject * _self,PyObject * _args)804 static 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 
Res_SetResLoad(PyObject * _self,PyObject * _args)826 static 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 
Res_CountResources(PyObject * _self,PyObject * _args)846 static 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 
Res_Count1Resources(PyObject * _self,PyObject * _args)867 static 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 
Res_GetIndResource(PyObject * _self,PyObject * _args)888 static 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 
Res_Get1IndResource(PyObject * _self,PyObject * _args)912 static 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 
Res_GetResource(PyObject * _self,PyObject * _args)936 static 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 
Res_Get1Resource(PyObject * _self,PyObject * _args)960 static 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 
Res_GetNamedResource(PyObject * _self,PyObject * _args)984 static 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 
Res_Get1NamedResource(PyObject * _self,PyObject * _args)1008 static 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 
Res_UniqueID(PyObject * _self,PyObject * _args)1032 static 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 
Res_Unique1ID(PyObject * _self,PyObject * _args)1053 static 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 
Res_UpdateResFile(PyObject * _self,PyObject * _args)1074 static 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 
Res_SetResPurge(PyObject * _self,PyObject * _args)1094 static 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 
Res_GetResFileAttrs(PyObject * _self,PyObject * _args)1114 static 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 
Res_SetResFileAttrs(PyObject * _self,PyObject * _args)1135 static 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__
Res_OpenRFPerm(PyObject * _self,PyObject * _args)1159 static 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 
Res_HOpenResFile(PyObject * _self,PyObject * _args)1186 static 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 
Res_HCreateResFile(PyObject * _self,PyObject * _args)1216 static 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 
Res_FSpOpenResFile(PyObject * _self,PyObject * _args)1242 static 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 
Res_FSpCreateResFile(PyObject * _self,PyObject * _args)1266 static 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 
Res_InsertResourceFile(PyObject * _self,PyObject * _args)1296 static 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 
Res_DetachResourceFile(PyObject * _self,PyObject * _args)1317 static 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__
Res_FSpResourceFileAlreadyOpen(PyObject * _self,PyObject * _args)1336 static 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 
Res_FSpOpenOrphanResFile(PyObject * _self,PyObject * _args)1363 static 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 
Res_GetTopResourceFile(PyObject * _self,PyObject * _args)1386 static 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 
Res_GetNextResourceFile(PyObject * _self,PyObject * _args)1404 static 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 
Res_FSOpenResFile(PyObject * _self,PyObject * _args)1425 static 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__
Res_FSCreateResFile(PyObject * _self,PyObject * _args)1451 static 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 
Res_FSResourceFileAlreadyOpen(PyObject * _self,PyObject * _args)1484 static 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 
Res_FSCreateResourceFile(PyObject * _self,PyObject * _args)1511 static 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 
Res_FSOpenResourceFile(PyObject * _self,PyObject * _args)1549 static 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 
Res_Handle(PyObject * _self,PyObject * _args)1578 static 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 
1604 static 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 */
OptResObj_New(Handle itself)1697 PyObject *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 
OptResObj_Convert(PyObject * v,Handle * p_itself)1706 int 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 
init_Res(void)1731 void 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