Mac/Modules/res/Resmodule.c

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