blob: 6eeb3b8bc356fc8224049d9a375057ca9aac3abf [file] [log] [blame]
Guido van Rossum17448e21995-01-30 11:53:55 +00001
2/* =========================== Module Res =========================== */
3
4#include "Python.h"
5
6
7
8#define SystemSevenOrLater 1
9
10#include "macglue.h"
11#include <Memory.h>
12#include <Dialogs.h>
13#include <Menus.h>
14#include <Controls.h>
15
16extern PyObject *ResObj_New(Handle);
17extern int ResObj_Convert(PyObject *, Handle *);
Jack Jansen425e9eb1995-12-12 15:02:03 +000018extern PyObject *OptResObj_New(Handle);
19extern int OptResObj_Convert(PyObject *, Handle *);
Guido van Rossum17448e21995-01-30 11:53:55 +000020
21extern PyObject *WinObj_New(WindowPtr);
22extern int WinObj_Convert(PyObject *, WindowPtr *);
Jack Jansen425e9eb1995-12-12 15:02:03 +000023extern PyTypeObject Window_Type;
24#define WinObj_Check(x) ((x)->ob_type == &Window_Type)
Guido van Rossum17448e21995-01-30 11:53:55 +000025
26extern PyObject *DlgObj_New(DialogPtr);
27extern int DlgObj_Convert(PyObject *, DialogPtr *);
28extern PyTypeObject Dialog_Type;
29#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
30
31extern PyObject *MenuObj_New(MenuHandle);
32extern int MenuObj_Convert(PyObject *, MenuHandle *);
33
34extern PyObject *CtlObj_New(ControlHandle);
35extern int CtlObj_Convert(PyObject *, ControlHandle *);
36
Jack Jansen425e9eb1995-12-12 15:02:03 +000037extern PyObject *GrafObj_New(GrafPtr);
38extern int GrafObj_Convert(PyObject *, GrafPtr *);
39
40extern PyObject *BMObj_New(BitMapPtr);
41extern int BMObj_Convert(PyObject *, BitMapPtr *);
42
Guido van Rossum9bcb6411995-02-05 16:54:27 +000043extern PyObject *WinObj_WhichWindow(WindowPtr);
44
Guido van Rossum17448e21995-01-30 11:53:55 +000045#include <Resources.h>
Jack Janseneaf3c9b1997-08-15 14:36:45 +000046#include <string.h>
Guido van Rossum17448e21995-01-30 11:53:55 +000047
48#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
49
50static PyObject *Res_Error;
51
52/* ---------------------- Object type Resource ---------------------- */
53
54PyTypeObject Resource_Type;
55
56#define ResObj_Check(x) ((x)->ob_type == &Resource_Type)
57
58typedef struct ResourceObject {
59 PyObject_HEAD
60 Handle ob_itself;
61} ResourceObject;
62
63PyObject *ResObj_New(itself)
Guido van Rossum227a4231995-03-10 14:42:57 +000064 Handle itself;
Guido van Rossum17448e21995-01-30 11:53:55 +000065{
66 ResourceObject *it;
67 if (itself == NULL) return PyMac_Error(resNotFound);
68 it = PyObject_NEW(ResourceObject, &Resource_Type);
69 if (it == NULL) return NULL;
70 it->ob_itself = itself;
71 return (PyObject *)it;
72}
73ResObj_Convert(v, p_itself)
74 PyObject *v;
75 Handle *p_itself;
76{
77 if (!ResObj_Check(v))
78 {
79 PyErr_SetString(PyExc_TypeError, "Resource required");
80 return 0;
81 }
82 *p_itself = ((ResourceObject *)v)->ob_itself;
83 return 1;
84}
85
86static void ResObj_dealloc(self)
87 ResourceObject *self;
88{
89 /* Cleanup of self->ob_itself goes here */
90 PyMem_DEL(self);
91}
92
93static PyObject *ResObj_HomeResFile(_self, _args)
94 ResourceObject *_self;
95 PyObject *_args;
96{
97 PyObject *_res = NULL;
98 short _rv;
99 if (!PyArg_ParseTuple(_args, ""))
100 return NULL;
101 _rv = HomeResFile(_self->ob_itself);
102 {
103 OSErr _err = ResError();
104 if (_err != noErr) return PyMac_Error(_err);
105 }
106 _res = Py_BuildValue("h",
107 _rv);
108 return _res;
109}
110
Jack Jansen1c4e6141998-04-21 15:23:55 +0000111static PyObject *ResObj_MacLoadResource(_self, _args)
Guido van Rossum17448e21995-01-30 11:53:55 +0000112 ResourceObject *_self;
113 PyObject *_args;
114{
115 PyObject *_res = NULL;
116 if (!PyArg_ParseTuple(_args, ""))
117 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000118 MacLoadResource(_self->ob_itself);
Guido van Rossum17448e21995-01-30 11:53:55 +0000119 {
120 OSErr _err = ResError();
121 if (_err != noErr) return PyMac_Error(_err);
122 }
123 Py_INCREF(Py_None);
124 _res = Py_None;
125 return _res;
126}
127
128static PyObject *ResObj_ReleaseResource(_self, _args)
129 ResourceObject *_self;
130 PyObject *_args;
131{
132 PyObject *_res = NULL;
133 if (!PyArg_ParseTuple(_args, ""))
134 return NULL;
135 ReleaseResource(_self->ob_itself);
136 {
137 OSErr _err = ResError();
138 if (_err != noErr) return PyMac_Error(_err);
139 }
140 Py_INCREF(Py_None);
141 _res = Py_None;
142 return _res;
143}
144
145static PyObject *ResObj_DetachResource(_self, _args)
146 ResourceObject *_self;
147 PyObject *_args;
148{
149 PyObject *_res = NULL;
150 if (!PyArg_ParseTuple(_args, ""))
151 return NULL;
152 DetachResource(_self->ob_itself);
153 {
154 OSErr _err = ResError();
155 if (_err != noErr) return PyMac_Error(_err);
156 }
157 Py_INCREF(Py_None);
158 _res = Py_None;
159 return _res;
160}
161
162static PyObject *ResObj_GetResAttrs(_self, _args)
163 ResourceObject *_self;
164 PyObject *_args;
165{
166 PyObject *_res = NULL;
167 short _rv;
168 if (!PyArg_ParseTuple(_args, ""))
169 return NULL;
170 _rv = GetResAttrs(_self->ob_itself);
171 {
172 OSErr _err = ResError();
173 if (_err != noErr) return PyMac_Error(_err);
174 }
175 _res = Py_BuildValue("h",
176 _rv);
177 return _res;
178}
179
180static PyObject *ResObj_GetResInfo(_self, _args)
181 ResourceObject *_self;
182 PyObject *_args;
183{
184 PyObject *_res = NULL;
185 short theID;
186 ResType theType;
187 Str255 name;
188 if (!PyArg_ParseTuple(_args, ""))
189 return NULL;
190 GetResInfo(_self->ob_itself,
191 &theID,
192 &theType,
193 name);
194 {
195 OSErr _err = ResError();
196 if (_err != noErr) return PyMac_Error(_err);
197 }
198 _res = Py_BuildValue("hO&O&",
199 theID,
200 PyMac_BuildOSType, theType,
201 PyMac_BuildStr255, name);
202 return _res;
203}
204
205static PyObject *ResObj_SetResInfo(_self, _args)
206 ResourceObject *_self;
207 PyObject *_args;
208{
209 PyObject *_res = NULL;
210 short theID;
211 Str255 name;
212 if (!PyArg_ParseTuple(_args, "hO&",
213 &theID,
214 PyMac_GetStr255, name))
215 return NULL;
216 SetResInfo(_self->ob_itself,
217 theID,
218 name);
219 {
220 OSErr _err = ResError();
221 if (_err != noErr) return PyMac_Error(_err);
222 }
223 Py_INCREF(Py_None);
224 _res = Py_None;
225 return _res;
226}
227
228static PyObject *ResObj_AddResource(_self, _args)
229 ResourceObject *_self;
230 PyObject *_args;
231{
232 PyObject *_res = NULL;
233 ResType theType;
234 short theID;
235 Str255 name;
236 if (!PyArg_ParseTuple(_args, "O&hO&",
237 PyMac_GetOSType, &theType,
238 &theID,
239 PyMac_GetStr255, name))
240 return NULL;
241 AddResource(_self->ob_itself,
242 theType,
243 theID,
244 name);
245 {
246 OSErr _err = ResError();
247 if (_err != noErr) return PyMac_Error(_err);
248 }
249 Py_INCREF(Py_None);
250 _res = Py_None;
251 return _res;
252}
253
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000254static PyObject *ResObj_GetResourceSizeOnDisk(_self, _args)
Guido van Rossum17448e21995-01-30 11:53:55 +0000255 ResourceObject *_self;
256 PyObject *_args;
257{
258 PyObject *_res = NULL;
259 long _rv;
260 if (!PyArg_ParseTuple(_args, ""))
261 return NULL;
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000262 _rv = GetResourceSizeOnDisk(_self->ob_itself);
Guido van Rossum17448e21995-01-30 11:53:55 +0000263 {
264 OSErr _err = ResError();
265 if (_err != noErr) return PyMac_Error(_err);
266 }
267 _res = Py_BuildValue("l",
268 _rv);
269 return _res;
270}
271
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000272static PyObject *ResObj_GetMaxResourceSize(_self, _args)
Guido van Rossum17448e21995-01-30 11:53:55 +0000273 ResourceObject *_self;
274 PyObject *_args;
275{
276 PyObject *_res = NULL;
277 long _rv;
278 if (!PyArg_ParseTuple(_args, ""))
279 return NULL;
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000280 _rv = GetMaxResourceSize(_self->ob_itself);
Guido van Rossum17448e21995-01-30 11:53:55 +0000281 {
282 OSErr _err = ResError();
283 if (_err != noErr) return PyMac_Error(_err);
284 }
285 _res = Py_BuildValue("l",
286 _rv);
287 return _res;
288}
289
290static PyObject *ResObj_RsrcMapEntry(_self, _args)
291 ResourceObject *_self;
292 PyObject *_args;
293{
294 PyObject *_res = NULL;
295 long _rv;
296 if (!PyArg_ParseTuple(_args, ""))
297 return NULL;
298 _rv = RsrcMapEntry(_self->ob_itself);
299 {
300 OSErr _err = ResError();
301 if (_err != noErr) return PyMac_Error(_err);
302 }
303 _res = Py_BuildValue("l",
304 _rv);
305 return _res;
306}
307
308static PyObject *ResObj_SetResAttrs(_self, _args)
309 ResourceObject *_self;
310 PyObject *_args;
311{
312 PyObject *_res = NULL;
313 short attrs;
314 if (!PyArg_ParseTuple(_args, "h",
315 &attrs))
316 return NULL;
317 SetResAttrs(_self->ob_itself,
318 attrs);
319 {
320 OSErr _err = ResError();
321 if (_err != noErr) return PyMac_Error(_err);
322 }
323 Py_INCREF(Py_None);
324 _res = Py_None;
325 return _res;
326}
327
328static PyObject *ResObj_ChangedResource(_self, _args)
329 ResourceObject *_self;
330 PyObject *_args;
331{
332 PyObject *_res = NULL;
333 if (!PyArg_ParseTuple(_args, ""))
334 return NULL;
335 ChangedResource(_self->ob_itself);
336 {
337 OSErr _err = ResError();
338 if (_err != noErr) return PyMac_Error(_err);
339 }
340 Py_INCREF(Py_None);
341 _res = Py_None;
342 return _res;
343}
344
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000345static PyObject *ResObj_RemoveResource(_self, _args)
Guido van Rossum17448e21995-01-30 11:53:55 +0000346 ResourceObject *_self;
347 PyObject *_args;
348{
349 PyObject *_res = NULL;
350 if (!PyArg_ParseTuple(_args, ""))
351 return NULL;
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000352 RemoveResource(_self->ob_itself);
Guido van Rossum17448e21995-01-30 11:53:55 +0000353 {
354 OSErr _err = ResError();
355 if (_err != noErr) return PyMac_Error(_err);
356 }
357 Py_INCREF(Py_None);
358 _res = Py_None;
359 return _res;
360}
361
362static PyObject *ResObj_WriteResource(_self, _args)
363 ResourceObject *_self;
364 PyObject *_args;
365{
366 PyObject *_res = NULL;
367 if (!PyArg_ParseTuple(_args, ""))
368 return NULL;
369 WriteResource(_self->ob_itself);
370 {
371 OSErr _err = ResError();
372 if (_err != noErr) return PyMac_Error(_err);
373 }
374 Py_INCREF(Py_None);
375 _res = Py_None;
376 return _res;
377}
378
379static PyObject *ResObj_SetResourceSize(_self, _args)
380 ResourceObject *_self;
381 PyObject *_args;
382{
383 PyObject *_res = NULL;
384 long newSize;
385 if (!PyArg_ParseTuple(_args, "l",
386 &newSize))
387 return NULL;
388 SetResourceSize(_self->ob_itself,
389 newSize);
390 {
391 OSErr _err = ResError();
392 if (_err != noErr) return PyMac_Error(_err);
393 }
394 Py_INCREF(Py_None);
395 _res = Py_None;
396 return _res;
397}
398
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000399static PyObject *ResObj_GetNextFOND(_self, _args)
400 ResourceObject *_self;
401 PyObject *_args;
402{
403 PyObject *_res = NULL;
404 Handle _rv;
405 if (!PyArg_ParseTuple(_args, ""))
406 return NULL;
407 _rv = GetNextFOND(_self->ob_itself);
408 {
409 OSErr _err = ResError();
410 if (_err != noErr) return PyMac_Error(_err);
411 }
412 _res = Py_BuildValue("O&",
413 ResObj_New, _rv);
414 return _res;
415}
416
Jack Jansen1e054021995-06-18 20:20:27 +0000417static PyObject *ResObj_as_Control(_self, _args)
418 ResourceObject *_self;
419 PyObject *_args;
420{
421 PyObject *_res = NULL;
422
423 return CtlObj_New((ControlHandle)_self->ob_itself);
424
425}
426
427static PyObject *ResObj_as_Menu(_self, _args)
428 ResourceObject *_self;
429 PyObject *_args;
430{
431 PyObject *_res = NULL;
432
433 return MenuObj_New((MenuHandle)_self->ob_itself);
434
435}
436
Jack Jansene180d991998-04-24 10:28:20 +0000437static PyObject *ResObj_LoadResource(_self, _args)
438 ResourceObject *_self;
439 PyObject *_args;
440{
441 PyObject *_res = NULL;
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
Guido van Rossum17448e21995-01-30 11:53:55 +0000454static PyMethodDef ResObj_methods[] = {
455 {"HomeResFile", (PyCFunction)ResObj_HomeResFile, 1,
456 "() -> (short _rv)"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000457 {"MacLoadResource", (PyCFunction)ResObj_MacLoadResource, 1,
Guido van Rossum17448e21995-01-30 11:53:55 +0000458 "() -> None"},
459 {"ReleaseResource", (PyCFunction)ResObj_ReleaseResource, 1,
460 "() -> None"},
461 {"DetachResource", (PyCFunction)ResObj_DetachResource, 1,
462 "() -> None"},
463 {"GetResAttrs", (PyCFunction)ResObj_GetResAttrs, 1,
464 "() -> (short _rv)"},
465 {"GetResInfo", (PyCFunction)ResObj_GetResInfo, 1,
466 "() -> (short theID, ResType theType, Str255 name)"},
467 {"SetResInfo", (PyCFunction)ResObj_SetResInfo, 1,
468 "(short theID, Str255 name) -> None"},
469 {"AddResource", (PyCFunction)ResObj_AddResource, 1,
470 "(ResType theType, short theID, Str255 name) -> None"},
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000471 {"GetResourceSizeOnDisk", (PyCFunction)ResObj_GetResourceSizeOnDisk, 1,
Guido van Rossum17448e21995-01-30 11:53:55 +0000472 "() -> (long _rv)"},
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000473 {"GetMaxResourceSize", (PyCFunction)ResObj_GetMaxResourceSize, 1,
Guido van Rossum17448e21995-01-30 11:53:55 +0000474 "() -> (long _rv)"},
475 {"RsrcMapEntry", (PyCFunction)ResObj_RsrcMapEntry, 1,
476 "() -> (long _rv)"},
477 {"SetResAttrs", (PyCFunction)ResObj_SetResAttrs, 1,
478 "(short attrs) -> None"},
479 {"ChangedResource", (PyCFunction)ResObj_ChangedResource, 1,
480 "() -> None"},
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000481 {"RemoveResource", (PyCFunction)ResObj_RemoveResource, 1,
Guido van Rossum17448e21995-01-30 11:53:55 +0000482 "() -> None"},
483 {"WriteResource", (PyCFunction)ResObj_WriteResource, 1,
484 "() -> None"},
485 {"SetResourceSize", (PyCFunction)ResObj_SetResourceSize, 1,
486 "(long newSize) -> None"},
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000487 {"GetNextFOND", (PyCFunction)ResObj_GetNextFOND, 1,
488 "() -> (Handle _rv)"},
Jack Jansen1e054021995-06-18 20:20:27 +0000489 {"as_Control", (PyCFunction)ResObj_as_Control, 1,
490 "Return this resource/handle as a Control"},
491 {"as_Menu", (PyCFunction)ResObj_as_Menu, 1,
492 "Return this resource/handle as a Menu"},
Jack Jansene180d991998-04-24 10:28:20 +0000493 {"LoadResource", (PyCFunction)ResObj_LoadResource, 1,
494 "() -> None"},
Guido van Rossum17448e21995-01-30 11:53:55 +0000495 {NULL, NULL, 0}
496};
497
498PyMethodChain ResObj_chain = { ResObj_methods, NULL };
499
500static PyObject *ResObj_getattr(self, name)
501 ResourceObject *self;
502 char *name;
503{
504
505 if (strcmp(name, "size") == 0)
506 return PyInt_FromLong(GetHandleSize(self->ob_itself));
507 if (strcmp(name, "data") == 0) {
508 PyObject *res;
509 char state;
510 state = HGetState(self->ob_itself);
511 HLock(self->ob_itself);
512 res = PyString_FromStringAndSize(
513 *self->ob_itself,
514 GetHandleSize(self->ob_itself));
515 HUnlock(self->ob_itself);
516 HSetState(self->ob_itself, state);
517 return res;
518 }
519 if (strcmp(name, "__members__") == 0)
520 return Py_BuildValue("[ss]", "data", "size");
521
522 return Py_FindMethodInChain(&ResObj_chain, (PyObject *)self, name);
523}
524
Jack Jansen1e054021995-06-18 20:20:27 +0000525static int
526ResObj_setattr(self, name, value)
527 ResourceObject *self;
528 char *name;
529 PyObject *value;
530{
531 char *data;
532 long size;
533
534 if (strcmp(name, "data") != 0 || value == NULL )
535 return -1;
536 if ( !PyString_Check(value) )
537 return -1;
538 size = PyString_Size(value);
539 data = PyString_AsString(value);
540 /* XXXX Do I need the GetState/SetState calls? */
541 SetHandleSize(self->ob_itself, size);
542 if ( MemError())
543 return -1;
544 HLock(self->ob_itself);
545 memcpy((char *)*self->ob_itself, data, size);
546 HUnlock(self->ob_itself);
547 /* XXXX Should I do the Changed call immedeately? */
548 return 0;
549}
550
Guido van Rossum17448e21995-01-30 11:53:55 +0000551
552PyTypeObject Resource_Type = {
553 PyObject_HEAD_INIT(&PyType_Type)
554 0, /*ob_size*/
555 "Resource", /*tp_name*/
556 sizeof(ResourceObject), /*tp_basicsize*/
557 0, /*tp_itemsize*/
558 /* methods */
559 (destructor) ResObj_dealloc, /*tp_dealloc*/
560 0, /*tp_print*/
561 (getattrfunc) ResObj_getattr, /*tp_getattr*/
562 (setattrfunc) ResObj_setattr, /*tp_setattr*/
563};
564
565/* -------------------- End object type Resource -------------------- */
566
567
568static PyObject *Res_InitResources(_self, _args)
569 PyObject *_self;
570 PyObject *_args;
571{
572 PyObject *_res = NULL;
573 short _rv;
574 if (!PyArg_ParseTuple(_args, ""))
575 return NULL;
576 _rv = InitResources();
577 {
578 OSErr _err = ResError();
579 if (_err != noErr) return PyMac_Error(_err);
580 }
581 _res = Py_BuildValue("h",
582 _rv);
583 return _res;
584}
585
586static PyObject *Res_RsrcZoneInit(_self, _args)
587 PyObject *_self;
588 PyObject *_args;
589{
590 PyObject *_res = NULL;
591 if (!PyArg_ParseTuple(_args, ""))
592 return NULL;
593 RsrcZoneInit();
594 {
595 OSErr _err = ResError();
596 if (_err != noErr) return PyMac_Error(_err);
597 }
598 Py_INCREF(Py_None);
599 _res = Py_None;
600 return _res;
601}
602
603static PyObject *Res_CloseResFile(_self, _args)
604 PyObject *_self;
605 PyObject *_args;
606{
607 PyObject *_res = NULL;
608 short refNum;
609 if (!PyArg_ParseTuple(_args, "h",
610 &refNum))
611 return NULL;
612 CloseResFile(refNum);
613 {
614 OSErr _err = ResError();
615 if (_err != noErr) return PyMac_Error(_err);
616 }
617 Py_INCREF(Py_None);
618 _res = Py_None;
619 return _res;
620}
621
622static PyObject *Res_ResError(_self, _args)
623 PyObject *_self;
624 PyObject *_args;
625{
626 PyObject *_res = NULL;
Jack Jansen21f96871998-02-20 16:02:09 +0000627 OSErr _rv;
Guido van Rossum17448e21995-01-30 11:53:55 +0000628 if (!PyArg_ParseTuple(_args, ""))
629 return NULL;
630 _rv = ResError();
631 {
632 OSErr _err = ResError();
633 if (_err != noErr) return PyMac_Error(_err);
634 }
635 _res = Py_BuildValue("h",
636 _rv);
637 return _res;
638}
639
640static PyObject *Res_CurResFile(_self, _args)
641 PyObject *_self;
642 PyObject *_args;
643{
644 PyObject *_res = NULL;
645 short _rv;
646 if (!PyArg_ParseTuple(_args, ""))
647 return NULL;
648 _rv = CurResFile();
649 {
650 OSErr _err = ResError();
651 if (_err != noErr) return PyMac_Error(_err);
652 }
653 _res = Py_BuildValue("h",
654 _rv);
655 return _res;
656}
657
658static PyObject *Res_CreateResFile(_self, _args)
659 PyObject *_self;
660 PyObject *_args;
661{
662 PyObject *_res = NULL;
663 Str255 fileName;
664 if (!PyArg_ParseTuple(_args, "O&",
665 PyMac_GetStr255, fileName))
666 return NULL;
667 CreateResFile(fileName);
668 {
669 OSErr _err = ResError();
670 if (_err != noErr) return PyMac_Error(_err);
671 }
672 Py_INCREF(Py_None);
673 _res = Py_None;
674 return _res;
675}
676
677static PyObject *Res_OpenResFile(_self, _args)
678 PyObject *_self;
679 PyObject *_args;
680{
681 PyObject *_res = NULL;
682 short _rv;
683 Str255 fileName;
684 if (!PyArg_ParseTuple(_args, "O&",
685 PyMac_GetStr255, fileName))
686 return NULL;
687 _rv = OpenResFile(fileName);
688 {
689 OSErr _err = ResError();
690 if (_err != noErr) return PyMac_Error(_err);
691 }
692 _res = Py_BuildValue("h",
693 _rv);
694 return _res;
695}
696
697static PyObject *Res_UseResFile(_self, _args)
698 PyObject *_self;
699 PyObject *_args;
700{
701 PyObject *_res = NULL;
702 short refNum;
703 if (!PyArg_ParseTuple(_args, "h",
704 &refNum))
705 return NULL;
706 UseResFile(refNum);
707 {
708 OSErr _err = ResError();
709 if (_err != noErr) return PyMac_Error(_err);
710 }
711 Py_INCREF(Py_None);
712 _res = Py_None;
713 return _res;
714}
715
716static PyObject *Res_CountTypes(_self, _args)
717 PyObject *_self;
718 PyObject *_args;
719{
720 PyObject *_res = NULL;
721 short _rv;
722 if (!PyArg_ParseTuple(_args, ""))
723 return NULL;
724 _rv = CountTypes();
725 {
726 OSErr _err = ResError();
727 if (_err != noErr) return PyMac_Error(_err);
728 }
729 _res = Py_BuildValue("h",
730 _rv);
731 return _res;
732}
733
734static PyObject *Res_Count1Types(_self, _args)
735 PyObject *_self;
736 PyObject *_args;
737{
738 PyObject *_res = NULL;
739 short _rv;
740 if (!PyArg_ParseTuple(_args, ""))
741 return NULL;
742 _rv = Count1Types();
743 {
744 OSErr _err = ResError();
745 if (_err != noErr) return PyMac_Error(_err);
746 }
747 _res = Py_BuildValue("h",
748 _rv);
749 return _res;
750}
751
752static PyObject *Res_GetIndType(_self, _args)
753 PyObject *_self;
754 PyObject *_args;
755{
756 PyObject *_res = NULL;
757 ResType theType;
758 short index;
759 if (!PyArg_ParseTuple(_args, "h",
760 &index))
761 return NULL;
762 GetIndType(&theType,
763 index);
764 {
765 OSErr _err = ResError();
766 if (_err != noErr) return PyMac_Error(_err);
767 }
768 _res = Py_BuildValue("O&",
769 PyMac_BuildOSType, theType);
770 return _res;
771}
772
773static PyObject *Res_Get1IndType(_self, _args)
774 PyObject *_self;
775 PyObject *_args;
776{
777 PyObject *_res = NULL;
778 ResType theType;
779 short index;
780 if (!PyArg_ParseTuple(_args, "h",
781 &index))
782 return NULL;
783 Get1IndType(&theType,
784 index);
785 {
786 OSErr _err = ResError();
787 if (_err != noErr) return PyMac_Error(_err);
788 }
789 _res = Py_BuildValue("O&",
790 PyMac_BuildOSType, theType);
791 return _res;
792}
793
794static PyObject *Res_SetResLoad(_self, _args)
795 PyObject *_self;
796 PyObject *_args;
797{
798 PyObject *_res = NULL;
799 Boolean load;
800 if (!PyArg_ParseTuple(_args, "b",
801 &load))
802 return NULL;
803 SetResLoad(load);
804 {
805 OSErr _err = ResError();
806 if (_err != noErr) return PyMac_Error(_err);
807 }
808 Py_INCREF(Py_None);
809 _res = Py_None;
810 return _res;
811}
812
813static PyObject *Res_CountResources(_self, _args)
814 PyObject *_self;
815 PyObject *_args;
816{
817 PyObject *_res = NULL;
818 short _rv;
819 ResType theType;
820 if (!PyArg_ParseTuple(_args, "O&",
821 PyMac_GetOSType, &theType))
822 return NULL;
823 _rv = CountResources(theType);
824 {
825 OSErr _err = ResError();
826 if (_err != noErr) return PyMac_Error(_err);
827 }
828 _res = Py_BuildValue("h",
829 _rv);
830 return _res;
831}
832
833static PyObject *Res_Count1Resources(_self, _args)
834 PyObject *_self;
835 PyObject *_args;
836{
837 PyObject *_res = NULL;
838 short _rv;
839 ResType theType;
840 if (!PyArg_ParseTuple(_args, "O&",
841 PyMac_GetOSType, &theType))
842 return NULL;
843 _rv = Count1Resources(theType);
844 {
845 OSErr _err = ResError();
846 if (_err != noErr) return PyMac_Error(_err);
847 }
848 _res = Py_BuildValue("h",
849 _rv);
850 return _res;
851}
852
853static PyObject *Res_GetIndResource(_self, _args)
854 PyObject *_self;
855 PyObject *_args;
856{
857 PyObject *_res = NULL;
858 Handle _rv;
859 ResType theType;
860 short index;
861 if (!PyArg_ParseTuple(_args, "O&h",
862 PyMac_GetOSType, &theType,
863 &index))
864 return NULL;
865 _rv = GetIndResource(theType,
866 index);
867 {
868 OSErr _err = ResError();
869 if (_err != noErr) return PyMac_Error(_err);
870 }
871 _res = Py_BuildValue("O&",
872 ResObj_New, _rv);
873 return _res;
874}
875
876static PyObject *Res_Get1IndResource(_self, _args)
877 PyObject *_self;
878 PyObject *_args;
879{
880 PyObject *_res = NULL;
881 Handle _rv;
882 ResType theType;
883 short index;
884 if (!PyArg_ParseTuple(_args, "O&h",
885 PyMac_GetOSType, &theType,
886 &index))
887 return NULL;
888 _rv = Get1IndResource(theType,
889 index);
890 {
891 OSErr _err = ResError();
892 if (_err != noErr) return PyMac_Error(_err);
893 }
894 _res = Py_BuildValue("O&",
895 ResObj_New, _rv);
896 return _res;
897}
898
899static PyObject *Res_GetResource(_self, _args)
900 PyObject *_self;
901 PyObject *_args;
902{
903 PyObject *_res = NULL;
904 Handle _rv;
905 ResType theType;
906 short theID;
907 if (!PyArg_ParseTuple(_args, "O&h",
908 PyMac_GetOSType, &theType,
909 &theID))
910 return NULL;
911 _rv = GetResource(theType,
912 theID);
913 {
914 OSErr _err = ResError();
915 if (_err != noErr) return PyMac_Error(_err);
916 }
917 _res = Py_BuildValue("O&",
918 ResObj_New, _rv);
919 return _res;
920}
921
922static PyObject *Res_Get1Resource(_self, _args)
923 PyObject *_self;
924 PyObject *_args;
925{
926 PyObject *_res = NULL;
927 Handle _rv;
928 ResType theType;
929 short theID;
930 if (!PyArg_ParseTuple(_args, "O&h",
931 PyMac_GetOSType, &theType,
932 &theID))
933 return NULL;
934 _rv = Get1Resource(theType,
935 theID);
936 {
937 OSErr _err = ResError();
938 if (_err != noErr) return PyMac_Error(_err);
939 }
940 _res = Py_BuildValue("O&",
941 ResObj_New, _rv);
942 return _res;
943}
944
945static PyObject *Res_GetNamedResource(_self, _args)
946 PyObject *_self;
947 PyObject *_args;
948{
949 PyObject *_res = NULL;
950 Handle _rv;
951 ResType theType;
952 Str255 name;
953 if (!PyArg_ParseTuple(_args, "O&O&",
954 PyMac_GetOSType, &theType,
955 PyMac_GetStr255, name))
956 return NULL;
957 _rv = GetNamedResource(theType,
958 name);
959 {
960 OSErr _err = ResError();
961 if (_err != noErr) return PyMac_Error(_err);
962 }
963 _res = Py_BuildValue("O&",
964 ResObj_New, _rv);
965 return _res;
966}
967
968static PyObject *Res_Get1NamedResource(_self, _args)
969 PyObject *_self;
970 PyObject *_args;
971{
972 PyObject *_res = NULL;
973 Handle _rv;
974 ResType theType;
975 Str255 name;
976 if (!PyArg_ParseTuple(_args, "O&O&",
977 PyMac_GetOSType, &theType,
978 PyMac_GetStr255, name))
979 return NULL;
980 _rv = Get1NamedResource(theType,
981 name);
982 {
983 OSErr _err = ResError();
984 if (_err != noErr) return PyMac_Error(_err);
985 }
986 _res = Py_BuildValue("O&",
987 ResObj_New, _rv);
988 return _res;
989}
990
991static PyObject *Res_UniqueID(_self, _args)
992 PyObject *_self;
993 PyObject *_args;
994{
995 PyObject *_res = NULL;
996 short _rv;
997 ResType theType;
998 if (!PyArg_ParseTuple(_args, "O&",
999 PyMac_GetOSType, &theType))
1000 return NULL;
1001 _rv = UniqueID(theType);
1002 {
1003 OSErr _err = ResError();
1004 if (_err != noErr) return PyMac_Error(_err);
1005 }
1006 _res = Py_BuildValue("h",
1007 _rv);
1008 return _res;
1009}
1010
1011static PyObject *Res_Unique1ID(_self, _args)
1012 PyObject *_self;
1013 PyObject *_args;
1014{
1015 PyObject *_res = NULL;
1016 short _rv;
1017 ResType theType;
1018 if (!PyArg_ParseTuple(_args, "O&",
1019 PyMac_GetOSType, &theType))
1020 return NULL;
1021 _rv = Unique1ID(theType);
1022 {
1023 OSErr _err = ResError();
1024 if (_err != noErr) return PyMac_Error(_err);
1025 }
1026 _res = Py_BuildValue("h",
1027 _rv);
1028 return _res;
1029}
1030
1031static PyObject *Res_UpdateResFile(_self, _args)
1032 PyObject *_self;
1033 PyObject *_args;
1034{
1035 PyObject *_res = NULL;
1036 short refNum;
1037 if (!PyArg_ParseTuple(_args, "h",
1038 &refNum))
1039 return NULL;
1040 UpdateResFile(refNum);
1041 {
1042 OSErr _err = ResError();
1043 if (_err != noErr) return PyMac_Error(_err);
1044 }
1045 Py_INCREF(Py_None);
1046 _res = Py_None;
1047 return _res;
1048}
1049
1050static PyObject *Res_SetResPurge(_self, _args)
1051 PyObject *_self;
1052 PyObject *_args;
1053{
1054 PyObject *_res = NULL;
1055 Boolean install;
1056 if (!PyArg_ParseTuple(_args, "b",
1057 &install))
1058 return NULL;
1059 SetResPurge(install);
1060 {
1061 OSErr _err = ResError();
1062 if (_err != noErr) return PyMac_Error(_err);
1063 }
1064 Py_INCREF(Py_None);
1065 _res = Py_None;
1066 return _res;
1067}
1068
1069static PyObject *Res_GetResFileAttrs(_self, _args)
1070 PyObject *_self;
1071 PyObject *_args;
1072{
1073 PyObject *_res = NULL;
1074 short _rv;
1075 short refNum;
1076 if (!PyArg_ParseTuple(_args, "h",
1077 &refNum))
1078 return NULL;
1079 _rv = GetResFileAttrs(refNum);
1080 {
1081 OSErr _err = ResError();
1082 if (_err != noErr) return PyMac_Error(_err);
1083 }
1084 _res = Py_BuildValue("h",
1085 _rv);
1086 return _res;
1087}
1088
1089static PyObject *Res_SetResFileAttrs(_self, _args)
1090 PyObject *_self;
1091 PyObject *_args;
1092{
1093 PyObject *_res = NULL;
1094 short refNum;
1095 short attrs;
1096 if (!PyArg_ParseTuple(_args, "hh",
1097 &refNum,
1098 &attrs))
1099 return NULL;
1100 SetResFileAttrs(refNum,
1101 attrs);
1102 {
1103 OSErr _err = ResError();
1104 if (_err != noErr) return PyMac_Error(_err);
1105 }
1106 Py_INCREF(Py_None);
1107 _res = Py_None;
1108 return _res;
1109}
1110
1111static PyObject *Res_OpenRFPerm(_self, _args)
1112 PyObject *_self;
1113 PyObject *_args;
1114{
1115 PyObject *_res = NULL;
1116 short _rv;
1117 Str255 fileName;
1118 short vRefNum;
Jack Jansenb81cf9d1995-06-06 13:08:40 +00001119 SignedByte permission;
1120 if (!PyArg_ParseTuple(_args, "O&hb",
Guido van Rossum17448e21995-01-30 11:53:55 +00001121 PyMac_GetStr255, fileName,
1122 &vRefNum,
1123 &permission))
1124 return NULL;
1125 _rv = OpenRFPerm(fileName,
1126 vRefNum,
1127 permission);
1128 {
1129 OSErr _err = ResError();
1130 if (_err != noErr) return PyMac_Error(_err);
1131 }
1132 _res = Py_BuildValue("h",
1133 _rv);
1134 return _res;
1135}
1136
1137static PyObject *Res_RGetResource(_self, _args)
1138 PyObject *_self;
1139 PyObject *_args;
1140{
1141 PyObject *_res = NULL;
1142 Handle _rv;
1143 ResType theType;
1144 short theID;
1145 if (!PyArg_ParseTuple(_args, "O&h",
1146 PyMac_GetOSType, &theType,
1147 &theID))
1148 return NULL;
1149 _rv = RGetResource(theType,
1150 theID);
1151 {
1152 OSErr _err = ResError();
1153 if (_err != noErr) return PyMac_Error(_err);
1154 }
1155 _res = Py_BuildValue("O&",
1156 ResObj_New, _rv);
1157 return _res;
1158}
1159
1160static PyObject *Res_HOpenResFile(_self, _args)
1161 PyObject *_self;
1162 PyObject *_args;
1163{
1164 PyObject *_res = NULL;
1165 short _rv;
1166 short vRefNum;
1167 long dirID;
1168 Str255 fileName;
Jack Jansenb81cf9d1995-06-06 13:08:40 +00001169 SignedByte permission;
1170 if (!PyArg_ParseTuple(_args, "hlO&b",
Guido van Rossum17448e21995-01-30 11:53:55 +00001171 &vRefNum,
1172 &dirID,
1173 PyMac_GetStr255, fileName,
1174 &permission))
1175 return NULL;
1176 _rv = HOpenResFile(vRefNum,
1177 dirID,
1178 fileName,
1179 permission);
1180 {
1181 OSErr _err = ResError();
1182 if (_err != noErr) return PyMac_Error(_err);
1183 }
1184 _res = Py_BuildValue("h",
1185 _rv);
1186 return _res;
1187}
1188
1189static PyObject *Res_HCreateResFile(_self, _args)
1190 PyObject *_self;
1191 PyObject *_args;
1192{
1193 PyObject *_res = NULL;
1194 short vRefNum;
1195 long dirID;
1196 Str255 fileName;
1197 if (!PyArg_ParseTuple(_args, "hlO&",
1198 &vRefNum,
1199 &dirID,
1200 PyMac_GetStr255, fileName))
1201 return NULL;
1202 HCreateResFile(vRefNum,
1203 dirID,
1204 fileName);
1205 {
1206 OSErr _err = ResError();
1207 if (_err != noErr) return PyMac_Error(_err);
1208 }
1209 Py_INCREF(Py_None);
1210 _res = Py_None;
1211 return _res;
1212}
1213
1214static PyObject *Res_FSpOpenResFile(_self, _args)
1215 PyObject *_self;
1216 PyObject *_args;
1217{
1218 PyObject *_res = NULL;
1219 short _rv;
1220 FSSpec spec;
1221 SignedByte permission;
1222 if (!PyArg_ParseTuple(_args, "O&b",
1223 PyMac_GetFSSpec, &spec,
1224 &permission))
1225 return NULL;
1226 _rv = FSpOpenResFile(&spec,
1227 permission);
1228 {
1229 OSErr _err = ResError();
1230 if (_err != noErr) return PyMac_Error(_err);
1231 }
1232 _res = Py_BuildValue("h",
1233 _rv);
1234 return _res;
1235}
1236
1237static PyObject *Res_FSpCreateResFile(_self, _args)
1238 PyObject *_self;
1239 PyObject *_args;
1240{
1241 PyObject *_res = NULL;
1242 FSSpec spec;
1243 OSType creator;
1244 OSType fileType;
1245 ScriptCode scriptTag;
1246 if (!PyArg_ParseTuple(_args, "O&O&O&h",
1247 PyMac_GetFSSpec, &spec,
1248 PyMac_GetOSType, &creator,
1249 PyMac_GetOSType, &fileType,
1250 &scriptTag))
1251 return NULL;
1252 FSpCreateResFile(&spec,
1253 creator,
1254 fileType,
1255 scriptTag);
1256 {
1257 OSErr _err = ResError();
1258 if (_err != noErr) return PyMac_Error(_err);
1259 }
1260 Py_INCREF(Py_None);
1261 _res = Py_None;
1262 return _res;
1263}
1264
Guido van Rossum9bcb6411995-02-05 16:54:27 +00001265static PyObject *Res_Resource(_self, _args)
1266 PyObject *_self;
1267 PyObject *_args;
1268{
1269 PyObject *_res = NULL;
1270
1271 char *buf;
1272 int len;
1273 Handle h;
1274
1275 if (!PyArg_ParseTuple(_args, "s#", &buf, &len))
1276 return NULL;
1277 h = NewHandle(len);
1278 if ( h == NULL ) {
1279 PyErr_NoMemory();
1280 return NULL;
1281 }
1282 HLock(h);
1283 memcpy(*h, buf, len);
1284 HUnlock(h);
1285 return (PyObject *)ResObj_New(h);
1286
1287}
1288
Guido van Rossum17448e21995-01-30 11:53:55 +00001289static PyMethodDef Res_methods[] = {
1290 {"InitResources", (PyCFunction)Res_InitResources, 1,
1291 "() -> (short _rv)"},
1292 {"RsrcZoneInit", (PyCFunction)Res_RsrcZoneInit, 1,
1293 "() -> None"},
1294 {"CloseResFile", (PyCFunction)Res_CloseResFile, 1,
1295 "(short refNum) -> None"},
1296 {"ResError", (PyCFunction)Res_ResError, 1,
Jack Jansen21f96871998-02-20 16:02:09 +00001297 "() -> (OSErr _rv)"},
Guido van Rossum17448e21995-01-30 11:53:55 +00001298 {"CurResFile", (PyCFunction)Res_CurResFile, 1,
1299 "() -> (short _rv)"},
1300 {"CreateResFile", (PyCFunction)Res_CreateResFile, 1,
1301 "(Str255 fileName) -> None"},
1302 {"OpenResFile", (PyCFunction)Res_OpenResFile, 1,
1303 "(Str255 fileName) -> (short _rv)"},
1304 {"UseResFile", (PyCFunction)Res_UseResFile, 1,
1305 "(short refNum) -> None"},
1306 {"CountTypes", (PyCFunction)Res_CountTypes, 1,
1307 "() -> (short _rv)"},
1308 {"Count1Types", (PyCFunction)Res_Count1Types, 1,
1309 "() -> (short _rv)"},
1310 {"GetIndType", (PyCFunction)Res_GetIndType, 1,
1311 "(short index) -> (ResType theType)"},
1312 {"Get1IndType", (PyCFunction)Res_Get1IndType, 1,
1313 "(short index) -> (ResType theType)"},
1314 {"SetResLoad", (PyCFunction)Res_SetResLoad, 1,
1315 "(Boolean load) -> None"},
1316 {"CountResources", (PyCFunction)Res_CountResources, 1,
1317 "(ResType theType) -> (short _rv)"},
1318 {"Count1Resources", (PyCFunction)Res_Count1Resources, 1,
1319 "(ResType theType) -> (short _rv)"},
1320 {"GetIndResource", (PyCFunction)Res_GetIndResource, 1,
1321 "(ResType theType, short index) -> (Handle _rv)"},
1322 {"Get1IndResource", (PyCFunction)Res_Get1IndResource, 1,
1323 "(ResType theType, short index) -> (Handle _rv)"},
1324 {"GetResource", (PyCFunction)Res_GetResource, 1,
1325 "(ResType theType, short theID) -> (Handle _rv)"},
1326 {"Get1Resource", (PyCFunction)Res_Get1Resource, 1,
1327 "(ResType theType, short theID) -> (Handle _rv)"},
1328 {"GetNamedResource", (PyCFunction)Res_GetNamedResource, 1,
1329 "(ResType theType, Str255 name) -> (Handle _rv)"},
1330 {"Get1NamedResource", (PyCFunction)Res_Get1NamedResource, 1,
1331 "(ResType theType, Str255 name) -> (Handle _rv)"},
1332 {"UniqueID", (PyCFunction)Res_UniqueID, 1,
1333 "(ResType theType) -> (short _rv)"},
1334 {"Unique1ID", (PyCFunction)Res_Unique1ID, 1,
1335 "(ResType theType) -> (short _rv)"},
1336 {"UpdateResFile", (PyCFunction)Res_UpdateResFile, 1,
1337 "(short refNum) -> None"},
1338 {"SetResPurge", (PyCFunction)Res_SetResPurge, 1,
1339 "(Boolean install) -> None"},
1340 {"GetResFileAttrs", (PyCFunction)Res_GetResFileAttrs, 1,
1341 "(short refNum) -> (short _rv)"},
1342 {"SetResFileAttrs", (PyCFunction)Res_SetResFileAttrs, 1,
1343 "(short refNum, short attrs) -> None"},
1344 {"OpenRFPerm", (PyCFunction)Res_OpenRFPerm, 1,
Jack Jansenb81cf9d1995-06-06 13:08:40 +00001345 "(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)"},
Guido van Rossum17448e21995-01-30 11:53:55 +00001346 {"RGetResource", (PyCFunction)Res_RGetResource, 1,
1347 "(ResType theType, short theID) -> (Handle _rv)"},
1348 {"HOpenResFile", (PyCFunction)Res_HOpenResFile, 1,
Jack Jansenb81cf9d1995-06-06 13:08:40 +00001349 "(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)"},
Guido van Rossum17448e21995-01-30 11:53:55 +00001350 {"HCreateResFile", (PyCFunction)Res_HCreateResFile, 1,
1351 "(short vRefNum, long dirID, Str255 fileName) -> None"},
1352 {"FSpOpenResFile", (PyCFunction)Res_FSpOpenResFile, 1,
1353 "(FSSpec spec, SignedByte permission) -> (short _rv)"},
1354 {"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1,
1355 "(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None"},
Guido van Rossum9bcb6411995-02-05 16:54:27 +00001356 {"Resource", (PyCFunction)Res_Resource, 1,
1357 "Convert a string to a resource object.\n\nThe created resource object is actually just a handle.\nApply AddResource() to write it to a resource file.\n"},
Guido van Rossum17448e21995-01-30 11:53:55 +00001358 {NULL, NULL, 0}
1359};
1360
1361
1362
1363
Jack Jansend4c26461995-08-17 14:35:56 +00001364/* Alternative version of ResObj_New, which returns None for null argument */
Jack Jansen425e9eb1995-12-12 15:02:03 +00001365PyObject *OptResObj_New(itself)
Jack Jansend4c26461995-08-17 14:35:56 +00001366 Handle itself;
1367{
Jack Jansend4c26461995-08-17 14:35:56 +00001368 if (itself == NULL) {
1369 Py_INCREF(Py_None);
1370 return Py_None;
1371 }
1372 return ResObj_New(itself);
1373}
1374
Jack Jansen425e9eb1995-12-12 15:02:03 +00001375OptResObj_Convert(v, p_itself)
1376 PyObject *v;
1377 Handle *p_itself;
1378{
1379 if ( v == Py_None ) {
1380 *p_itself = NULL;
1381 return 1;
1382 }
1383 if (!ResObj_Check(v))
1384 {
1385 PyErr_SetString(PyExc_TypeError, "Resource required");
1386 return 0;
1387 }
1388 *p_itself = ((ResourceObject *)v)->ob_itself;
1389 return 1;
1390}
1391
Jack Jansend4c26461995-08-17 14:35:56 +00001392
Guido van Rossum17448e21995-01-30 11:53:55 +00001393
1394void initRes()
1395{
1396 PyObject *m;
1397 PyObject *d;
1398
1399
1400
1401
1402
1403 m = Py_InitModule("Res", Res_methods);
1404 d = PyModule_GetDict(m);
1405 Res_Error = PyMac_GetOSErrException();
1406 if (Res_Error == NULL ||
1407 PyDict_SetItemString(d, "Error", Res_Error) != 0)
1408 Py_FatalError("can't initialize Res.Error");
Jack Jansena755e681997-09-20 17:40:22 +00001409 Resource_Type.ob_type = &PyType_Type;
1410 Py_INCREF(&Resource_Type);
1411 if (PyDict_SetItemString(d, "ResourceType", (PyObject *)&Resource_Type) != 0)
1412 Py_FatalError("can't initialize ResourceType");
Guido van Rossum17448e21995-01-30 11:53:55 +00001413}
1414
1415/* ========================= End module Res ========================= */
1416