Mac/Modules/res/_Resmodule.c

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