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