Mac/Modules/res/_Resmodule.c

   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
  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
  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
  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
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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__
 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
 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
 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
 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
 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
 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 immedeately? */
 555             return 0;
 556
 557     return 0;
 558 }
 559
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
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
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
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
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
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
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
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__
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
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
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
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
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
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
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__
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
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
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
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
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__
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
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
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
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
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 */
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
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
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