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