Mac/Modules/res/Resmodule.c

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