/Mac/Modules/icn/_Icnmodule.c
C | 1607 lines | 1521 code | 83 blank | 3 comment | 161 complexity | 71481573c2e486028080280a7be03bd8 MD5 | raw file
1 2/* ========================== Module _Icn =========================== */ 3 4#include "Python.h" 5 6 7#ifndef __LP64__ 8 9#include "pymactoolbox.h" 10 11/* Macro to test whether a weak-loaded CFM function exists */ 12#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ 13 PyErr_SetString(PyExc_NotImplementedError, \ 14 "Not available in this shared library/OS version"); \ 15 return NULL; \ 16 }} while(0) 17 18 19#include <Carbon/Carbon.h> 20 21 22static PyObject *Icn_Error; 23 24static PyObject *Icn_GetCIcon(PyObject *_self, PyObject *_args) 25{ 26 PyObject *_res = NULL; 27 CIconHandle _rv; 28 SInt16 iconID; 29#ifndef GetCIcon 30 PyMac_PRECHECK(GetCIcon); 31#endif 32 if (!PyArg_ParseTuple(_args, "h", 33 &iconID)) 34 return NULL; 35 _rv = GetCIcon(iconID); 36 _res = Py_BuildValue("O&", 37 ResObj_New, _rv); 38 return _res; 39} 40 41static PyObject *Icn_PlotCIcon(PyObject *_self, PyObject *_args) 42{ 43 PyObject *_res = NULL; 44 Rect theRect; 45 CIconHandle theIcon; 46#ifndef PlotCIcon 47 PyMac_PRECHECK(PlotCIcon); 48#endif 49 if (!PyArg_ParseTuple(_args, "O&O&", 50 PyMac_GetRect, &theRect, 51 ResObj_Convert, &theIcon)) 52 return NULL; 53 PlotCIcon(&theRect, 54 theIcon); 55 Py_INCREF(Py_None); 56 _res = Py_None; 57 return _res; 58} 59 60static PyObject *Icn_DisposeCIcon(PyObject *_self, PyObject *_args) 61{ 62 PyObject *_res = NULL; 63 CIconHandle theIcon; 64#ifndef DisposeCIcon 65 PyMac_PRECHECK(DisposeCIcon); 66#endif 67 if (!PyArg_ParseTuple(_args, "O&", 68 ResObj_Convert, &theIcon)) 69 return NULL; 70 DisposeCIcon(theIcon); 71 Py_INCREF(Py_None); 72 _res = Py_None; 73 return _res; 74} 75 76static PyObject *Icn_GetIcon(PyObject *_self, PyObject *_args) 77{ 78 PyObject *_res = NULL; 79 Handle _rv; 80 SInt16 iconID; 81#ifndef GetIcon 82 PyMac_PRECHECK(GetIcon); 83#endif 84 if (!PyArg_ParseTuple(_args, "h", 85 &iconID)) 86 return NULL; 87 _rv = GetIcon(iconID); 88 _res = Py_BuildValue("O&", 89 ResObj_New, _rv); 90 return _res; 91} 92 93static PyObject *Icn_PlotIcon(PyObject *_self, PyObject *_args) 94{ 95 PyObject *_res = NULL; 96 Rect theRect; 97 Handle theIcon; 98#ifndef PlotIcon 99 PyMac_PRECHECK(PlotIcon); 100#endif 101 if (!PyArg_ParseTuple(_args, "O&O&", 102 PyMac_GetRect, &theRect, 103 ResObj_Convert, &theIcon)) 104 return NULL; 105 PlotIcon(&theRect, 106 theIcon); 107 Py_INCREF(Py_None); 108 _res = Py_None; 109 return _res; 110} 111 112static PyObject *Icn_PlotIconID(PyObject *_self, PyObject *_args) 113{ 114 PyObject *_res = NULL; 115 OSErr _err; 116 Rect theRect; 117 IconAlignmentType align; 118 IconTransformType transform; 119 SInt16 theResID; 120#ifndef PlotIconID 121 PyMac_PRECHECK(PlotIconID); 122#endif 123 if (!PyArg_ParseTuple(_args, "O&hhh", 124 PyMac_GetRect, &theRect, 125 &align, 126 &transform, 127 &theResID)) 128 return NULL; 129 _err = PlotIconID(&theRect, 130 align, 131 transform, 132 theResID); 133 if (_err != noErr) return PyMac_Error(_err); 134 Py_INCREF(Py_None); 135 _res = Py_None; 136 return _res; 137} 138 139static PyObject *Icn_NewIconSuite(PyObject *_self, PyObject *_args) 140{ 141 PyObject *_res = NULL; 142 OSErr _err; 143 IconSuiteRef theIconSuite; 144#ifndef NewIconSuite 145 PyMac_PRECHECK(NewIconSuite); 146#endif 147 if (!PyArg_ParseTuple(_args, "")) 148 return NULL; 149 _err = NewIconSuite(&theIconSuite); 150 if (_err != noErr) return PyMac_Error(_err); 151 _res = Py_BuildValue("O&", 152 ResObj_New, theIconSuite); 153 return _res; 154} 155 156static PyObject *Icn_AddIconToSuite(PyObject *_self, PyObject *_args) 157{ 158 PyObject *_res = NULL; 159 OSErr _err; 160 Handle theIconData; 161 IconSuiteRef theSuite; 162 ResType theType; 163#ifndef AddIconToSuite 164 PyMac_PRECHECK(AddIconToSuite); 165#endif 166 if (!PyArg_ParseTuple(_args, "O&O&O&", 167 ResObj_Convert, &theIconData, 168 ResObj_Convert, &theSuite, 169 PyMac_GetOSType, &theType)) 170 return NULL; 171 _err = AddIconToSuite(theIconData, 172 theSuite, 173 theType); 174 if (_err != noErr) return PyMac_Error(_err); 175 Py_INCREF(Py_None); 176 _res = Py_None; 177 return _res; 178} 179 180static PyObject *Icn_GetIconFromSuite(PyObject *_self, PyObject *_args) 181{ 182 PyObject *_res = NULL; 183 OSErr _err; 184 Handle theIconData; 185 IconSuiteRef theSuite; 186 ResType theType; 187#ifndef GetIconFromSuite 188 PyMac_PRECHECK(GetIconFromSuite); 189#endif 190 if (!PyArg_ParseTuple(_args, "O&O&", 191 ResObj_Convert, &theSuite, 192 PyMac_GetOSType, &theType)) 193 return NULL; 194 _err = GetIconFromSuite(&theIconData, 195 theSuite, 196 theType); 197 if (_err != noErr) return PyMac_Error(_err); 198 _res = Py_BuildValue("O&", 199 ResObj_New, theIconData); 200 return _res; 201} 202 203static PyObject *Icn_GetIconSuite(PyObject *_self, PyObject *_args) 204{ 205 PyObject *_res = NULL; 206 OSErr _err; 207 IconSuiteRef theIconSuite; 208 SInt16 theResID; 209 IconSelectorValue selector; 210#ifndef GetIconSuite 211 PyMac_PRECHECK(GetIconSuite); 212#endif 213 if (!PyArg_ParseTuple(_args, "hl", 214 &theResID, 215 &selector)) 216 return NULL; 217 _err = GetIconSuite(&theIconSuite, 218 theResID, 219 selector); 220 if (_err != noErr) return PyMac_Error(_err); 221 _res = Py_BuildValue("O&", 222 ResObj_New, theIconSuite); 223 return _res; 224} 225 226static PyObject *Icn_DisposeIconSuite(PyObject *_self, PyObject *_args) 227{ 228 PyObject *_res = NULL; 229 OSErr _err; 230 IconSuiteRef theIconSuite; 231 Boolean disposeData; 232#ifndef DisposeIconSuite 233 PyMac_PRECHECK(DisposeIconSuite); 234#endif 235 if (!PyArg_ParseTuple(_args, "O&b", 236 ResObj_Convert, &theIconSuite, 237 &disposeData)) 238 return NULL; 239 _err = DisposeIconSuite(theIconSuite, 240 disposeData); 241 if (_err != noErr) return PyMac_Error(_err); 242 Py_INCREF(Py_None); 243 _res = Py_None; 244 return _res; 245} 246 247static PyObject *Icn_PlotIconSuite(PyObject *_self, PyObject *_args) 248{ 249 PyObject *_res = NULL; 250 OSErr _err; 251 Rect theRect; 252 IconAlignmentType align; 253 IconTransformType transform; 254 IconSuiteRef theIconSuite; 255#ifndef PlotIconSuite 256 PyMac_PRECHECK(PlotIconSuite); 257#endif 258 if (!PyArg_ParseTuple(_args, "O&hhO&", 259 PyMac_GetRect, &theRect, 260 &align, 261 &transform, 262 ResObj_Convert, &theIconSuite)) 263 return NULL; 264 _err = PlotIconSuite(&theRect, 265 align, 266 transform, 267 theIconSuite); 268 if (_err != noErr) return PyMac_Error(_err); 269 Py_INCREF(Py_None); 270 _res = Py_None; 271 return _res; 272} 273 274static PyObject *Icn_LoadIconCache(PyObject *_self, PyObject *_args) 275{ 276 PyObject *_res = NULL; 277 OSErr _err; 278 Rect theRect; 279 IconAlignmentType align; 280 IconTransformType transform; 281 IconCacheRef theIconCache; 282#ifndef LoadIconCache 283 PyMac_PRECHECK(LoadIconCache); 284#endif 285 if (!PyArg_ParseTuple(_args, "O&hhO&", 286 PyMac_GetRect, &theRect, 287 &align, 288 &transform, 289 ResObj_Convert, &theIconCache)) 290 return NULL; 291 _err = LoadIconCache(&theRect, 292 align, 293 transform, 294 theIconCache); 295 if (_err != noErr) return PyMac_Error(_err); 296 Py_INCREF(Py_None); 297 _res = Py_None; 298 return _res; 299} 300 301static PyObject *Icn_GetLabel(PyObject *_self, PyObject *_args) 302{ 303 PyObject *_res = NULL; 304 OSErr _err; 305 SInt16 labelNumber; 306 RGBColor labelColor; 307 Str255 labelString; 308#ifndef GetLabel 309 PyMac_PRECHECK(GetLabel); 310#endif 311 if (!PyArg_ParseTuple(_args, "hO&", 312 &labelNumber, 313 PyMac_GetStr255, labelString)) 314 return NULL; 315 _err = GetLabel(labelNumber, 316 &labelColor, 317 labelString); 318 if (_err != noErr) return PyMac_Error(_err); 319 _res = Py_BuildValue("O&", 320 QdRGB_New, &labelColor); 321 return _res; 322} 323 324static PyObject *Icn_PtInIconID(PyObject *_self, PyObject *_args) 325{ 326 PyObject *_res = NULL; 327 Boolean _rv; 328 Point testPt; 329 Rect iconRect; 330 IconAlignmentType align; 331 SInt16 iconID; 332#ifndef PtInIconID 333 PyMac_PRECHECK(PtInIconID); 334#endif 335 if (!PyArg_ParseTuple(_args, "O&O&hh", 336 PyMac_GetPoint, &testPt, 337 PyMac_GetRect, &iconRect, 338 &align, 339 &iconID)) 340 return NULL; 341 _rv = PtInIconID(testPt, 342 &iconRect, 343 align, 344 iconID); 345 _res = Py_BuildValue("b", 346 _rv); 347 return _res; 348} 349 350static PyObject *Icn_PtInIconSuite(PyObject *_self, PyObject *_args) 351{ 352 PyObject *_res = NULL; 353 Boolean _rv; 354 Point testPt; 355 Rect iconRect; 356 IconAlignmentType align; 357 IconSuiteRef theIconSuite; 358#ifndef PtInIconSuite 359 PyMac_PRECHECK(PtInIconSuite); 360#endif 361 if (!PyArg_ParseTuple(_args, "O&O&hO&", 362 PyMac_GetPoint, &testPt, 363 PyMac_GetRect, &iconRect, 364 &align, 365 ResObj_Convert, &theIconSuite)) 366 return NULL; 367 _rv = PtInIconSuite(testPt, 368 &iconRect, 369 align, 370 theIconSuite); 371 _res = Py_BuildValue("b", 372 _rv); 373 return _res; 374} 375 376static PyObject *Icn_RectInIconID(PyObject *_self, PyObject *_args) 377{ 378 PyObject *_res = NULL; 379 Boolean _rv; 380 Rect testRect; 381 Rect iconRect; 382 IconAlignmentType align; 383 SInt16 iconID; 384#ifndef RectInIconID 385 PyMac_PRECHECK(RectInIconID); 386#endif 387 if (!PyArg_ParseTuple(_args, "O&O&hh", 388 PyMac_GetRect, &testRect, 389 PyMac_GetRect, &iconRect, 390 &align, 391 &iconID)) 392 return NULL; 393 _rv = RectInIconID(&testRect, 394 &iconRect, 395 align, 396 iconID); 397 _res = Py_BuildValue("b", 398 _rv); 399 return _res; 400} 401 402static PyObject *Icn_RectInIconSuite(PyObject *_self, PyObject *_args) 403{ 404 PyObject *_res = NULL; 405 Boolean _rv; 406 Rect testRect; 407 Rect iconRect; 408 IconAlignmentType align; 409 IconSuiteRef theIconSuite; 410#ifndef RectInIconSuite 411 PyMac_PRECHECK(RectInIconSuite); 412#endif 413 if (!PyArg_ParseTuple(_args, "O&O&hO&", 414 PyMac_GetRect, &testRect, 415 PyMac_GetRect, &iconRect, 416 &align, 417 ResObj_Convert, &theIconSuite)) 418 return NULL; 419 _rv = RectInIconSuite(&testRect, 420 &iconRect, 421 align, 422 theIconSuite); 423 _res = Py_BuildValue("b", 424 _rv); 425 return _res; 426} 427 428static PyObject *Icn_IconIDToRgn(PyObject *_self, PyObject *_args) 429{ 430 PyObject *_res = NULL; 431 OSErr _err; 432 RgnHandle theRgn; 433 Rect iconRect; 434 IconAlignmentType align; 435 SInt16 iconID; 436#ifndef IconIDToRgn 437 PyMac_PRECHECK(IconIDToRgn); 438#endif 439 if (!PyArg_ParseTuple(_args, "O&O&hh", 440 ResObj_Convert, &theRgn, 441 PyMac_GetRect, &iconRect, 442 &align, 443 &iconID)) 444 return NULL; 445 _err = IconIDToRgn(theRgn, 446 &iconRect, 447 align, 448 iconID); 449 if (_err != noErr) return PyMac_Error(_err); 450 Py_INCREF(Py_None); 451 _res = Py_None; 452 return _res; 453} 454 455static PyObject *Icn_IconSuiteToRgn(PyObject *_self, PyObject *_args) 456{ 457 PyObject *_res = NULL; 458 OSErr _err; 459 RgnHandle theRgn; 460 Rect iconRect; 461 IconAlignmentType align; 462 IconSuiteRef theIconSuite; 463#ifndef IconSuiteToRgn 464 PyMac_PRECHECK(IconSuiteToRgn); 465#endif 466 if (!PyArg_ParseTuple(_args, "O&O&hO&", 467 ResObj_Convert, &theRgn, 468 PyMac_GetRect, &iconRect, 469 &align, 470 ResObj_Convert, &theIconSuite)) 471 return NULL; 472 _err = IconSuiteToRgn(theRgn, 473 &iconRect, 474 align, 475 theIconSuite); 476 if (_err != noErr) return PyMac_Error(_err); 477 Py_INCREF(Py_None); 478 _res = Py_None; 479 return _res; 480} 481 482static PyObject *Icn_SetSuiteLabel(PyObject *_self, PyObject *_args) 483{ 484 PyObject *_res = NULL; 485 OSErr _err; 486 IconSuiteRef theSuite; 487 SInt16 theLabel; 488#ifndef SetSuiteLabel 489 PyMac_PRECHECK(SetSuiteLabel); 490#endif 491 if (!PyArg_ParseTuple(_args, "O&h", 492 ResObj_Convert, &theSuite, 493 &theLabel)) 494 return NULL; 495 _err = SetSuiteLabel(theSuite, 496 theLabel); 497 if (_err != noErr) return PyMac_Error(_err); 498 Py_INCREF(Py_None); 499 _res = Py_None; 500 return _res; 501} 502 503static PyObject *Icn_GetSuiteLabel(PyObject *_self, PyObject *_args) 504{ 505 PyObject *_res = NULL; 506 SInt16 _rv; 507 IconSuiteRef theSuite; 508#ifndef GetSuiteLabel 509 PyMac_PRECHECK(GetSuiteLabel); 510#endif 511 if (!PyArg_ParseTuple(_args, "O&", 512 ResObj_Convert, &theSuite)) 513 return NULL; 514 _rv = GetSuiteLabel(theSuite); 515 _res = Py_BuildValue("h", 516 _rv); 517 return _res; 518} 519 520static PyObject *Icn_PlotIconHandle(PyObject *_self, PyObject *_args) 521{ 522 PyObject *_res = NULL; 523 OSErr _err; 524 Rect theRect; 525 IconAlignmentType align; 526 IconTransformType transform; 527 Handle theIcon; 528#ifndef PlotIconHandle 529 PyMac_PRECHECK(PlotIconHandle); 530#endif 531 if (!PyArg_ParseTuple(_args, "O&hhO&", 532 PyMac_GetRect, &theRect, 533 &align, 534 &transform, 535 ResObj_Convert, &theIcon)) 536 return NULL; 537 _err = PlotIconHandle(&theRect, 538 align, 539 transform, 540 theIcon); 541 if (_err != noErr) return PyMac_Error(_err); 542 Py_INCREF(Py_None); 543 _res = Py_None; 544 return _res; 545} 546 547static PyObject *Icn_PlotSICNHandle(PyObject *_self, PyObject *_args) 548{ 549 PyObject *_res = NULL; 550 OSErr _err; 551 Rect theRect; 552 IconAlignmentType align; 553 IconTransformType transform; 554 Handle theSICN; 555#ifndef PlotSICNHandle 556 PyMac_PRECHECK(PlotSICNHandle); 557#endif 558 if (!PyArg_ParseTuple(_args, "O&hhO&", 559 PyMac_GetRect, &theRect, 560 &align, 561 &transform, 562 ResObj_Convert, &theSICN)) 563 return NULL; 564 _err = PlotSICNHandle(&theRect, 565 align, 566 transform, 567 theSICN); 568 if (_err != noErr) return PyMac_Error(_err); 569 Py_INCREF(Py_None); 570 _res = Py_None; 571 return _res; 572} 573 574static PyObject *Icn_PlotCIconHandle(PyObject *_self, PyObject *_args) 575{ 576 PyObject *_res = NULL; 577 OSErr _err; 578 Rect theRect; 579 IconAlignmentType align; 580 IconTransformType transform; 581 CIconHandle theCIcon; 582#ifndef PlotCIconHandle 583 PyMac_PRECHECK(PlotCIconHandle); 584#endif 585 if (!PyArg_ParseTuple(_args, "O&hhO&", 586 PyMac_GetRect, &theRect, 587 &align, 588 &transform, 589 ResObj_Convert, &theCIcon)) 590 return NULL; 591 _err = PlotCIconHandle(&theRect, 592 align, 593 transform, 594 theCIcon); 595 if (_err != noErr) return PyMac_Error(_err); 596 Py_INCREF(Py_None); 597 _res = Py_None; 598 return _res; 599} 600 601static PyObject *Icn_IconRefToIconFamily(PyObject *_self, PyObject *_args) 602{ 603 PyObject *_res = NULL; 604 OSErr _err; 605 IconRef theIconRef; 606 IconSelectorValue whichIcons; 607 IconFamilyHandle iconFamily; 608#ifndef IconRefToIconFamily 609 PyMac_PRECHECK(IconRefToIconFamily); 610#endif 611 if (!PyArg_ParseTuple(_args, "O&l", 612 ResObj_Convert, &theIconRef, 613 &whichIcons)) 614 return NULL; 615 _err = IconRefToIconFamily(theIconRef, 616 whichIcons, 617 &iconFamily); 618 if (_err != noErr) return PyMac_Error(_err); 619 _res = Py_BuildValue("O&", 620 ResObj_New, iconFamily); 621 return _res; 622} 623 624static PyObject *Icn_IconFamilyToIconSuite(PyObject *_self, PyObject *_args) 625{ 626 PyObject *_res = NULL; 627 OSErr _err; 628 IconFamilyHandle iconFamily; 629 IconSelectorValue whichIcons; 630 IconSuiteRef iconSuite; 631#ifndef IconFamilyToIconSuite 632 PyMac_PRECHECK(IconFamilyToIconSuite); 633#endif 634 if (!PyArg_ParseTuple(_args, "O&l", 635 ResObj_Convert, &iconFamily, 636 &whichIcons)) 637 return NULL; 638 _err = IconFamilyToIconSuite(iconFamily, 639 whichIcons, 640 &iconSuite); 641 if (_err != noErr) return PyMac_Error(_err); 642 _res = Py_BuildValue("O&", 643 ResObj_New, iconSuite); 644 return _res; 645} 646 647static PyObject *Icn_IconSuiteToIconFamily(PyObject *_self, PyObject *_args) 648{ 649 PyObject *_res = NULL; 650 OSErr _err; 651 IconSuiteRef iconSuite; 652 IconSelectorValue whichIcons; 653 IconFamilyHandle iconFamily; 654#ifndef IconSuiteToIconFamily 655 PyMac_PRECHECK(IconSuiteToIconFamily); 656#endif 657 if (!PyArg_ParseTuple(_args, "O&l", 658 ResObj_Convert, &iconSuite, 659 &whichIcons)) 660 return NULL; 661 _err = IconSuiteToIconFamily(iconSuite, 662 whichIcons, 663 &iconFamily); 664 if (_err != noErr) return PyMac_Error(_err); 665 _res = Py_BuildValue("O&", 666 ResObj_New, iconFamily); 667 return _res; 668} 669 670static PyObject *Icn_SetIconFamilyData(PyObject *_self, PyObject *_args) 671{ 672 PyObject *_res = NULL; 673 OSErr _err; 674 IconFamilyHandle iconFamily; 675 OSType iconType; 676 Handle h; 677#ifndef SetIconFamilyData 678 PyMac_PRECHECK(SetIconFamilyData); 679#endif 680 if (!PyArg_ParseTuple(_args, "O&O&O&", 681 ResObj_Convert, &iconFamily, 682 PyMac_GetOSType, &iconType, 683 ResObj_Convert, &h)) 684 return NULL; 685 _err = SetIconFamilyData(iconFamily, 686 iconType, 687 h); 688 if (_err != noErr) return PyMac_Error(_err); 689 Py_INCREF(Py_None); 690 _res = Py_None; 691 return _res; 692} 693 694static PyObject *Icn_GetIconFamilyData(PyObject *_self, PyObject *_args) 695{ 696 PyObject *_res = NULL; 697 OSErr _err; 698 IconFamilyHandle iconFamily; 699 OSType iconType; 700 Handle h; 701#ifndef GetIconFamilyData 702 PyMac_PRECHECK(GetIconFamilyData); 703#endif 704 if (!PyArg_ParseTuple(_args, "O&O&O&", 705 ResObj_Convert, &iconFamily, 706 PyMac_GetOSType, &iconType, 707 ResObj_Convert, &h)) 708 return NULL; 709 _err = GetIconFamilyData(iconFamily, 710 iconType, 711 h); 712 if (_err != noErr) return PyMac_Error(_err); 713 Py_INCREF(Py_None); 714 _res = Py_None; 715 return _res; 716} 717 718static PyObject *Icn_GetIconRefOwners(PyObject *_self, PyObject *_args) 719{ 720 PyObject *_res = NULL; 721 OSErr _err; 722 IconRef theIconRef; 723 UInt16 owners; 724#ifndef GetIconRefOwners 725 PyMac_PRECHECK(GetIconRefOwners); 726#endif 727 if (!PyArg_ParseTuple(_args, "O&", 728 ResObj_Convert, &theIconRef)) 729 return NULL; 730 _err = GetIconRefOwners(theIconRef, 731 &owners); 732 if (_err != noErr) return PyMac_Error(_err); 733 _res = Py_BuildValue("H", 734 owners); 735 return _res; 736} 737 738static PyObject *Icn_AcquireIconRef(PyObject *_self, PyObject *_args) 739{ 740 PyObject *_res = NULL; 741 OSErr _err; 742 IconRef theIconRef; 743#ifndef AcquireIconRef 744 PyMac_PRECHECK(AcquireIconRef); 745#endif 746 if (!PyArg_ParseTuple(_args, "O&", 747 ResObj_Convert, &theIconRef)) 748 return NULL; 749 _err = AcquireIconRef(theIconRef); 750 if (_err != noErr) return PyMac_Error(_err); 751 Py_INCREF(Py_None); 752 _res = Py_None; 753 return _res; 754} 755 756static PyObject *Icn_ReleaseIconRef(PyObject *_self, PyObject *_args) 757{ 758 PyObject *_res = NULL; 759 OSErr _err; 760 IconRef theIconRef; 761#ifndef ReleaseIconRef 762 PyMac_PRECHECK(ReleaseIconRef); 763#endif 764 if (!PyArg_ParseTuple(_args, "O&", 765 ResObj_Convert, &theIconRef)) 766 return NULL; 767 _err = ReleaseIconRef(theIconRef); 768 if (_err != noErr) return PyMac_Error(_err); 769 Py_INCREF(Py_None); 770 _res = Py_None; 771 return _res; 772} 773 774static PyObject *Icn_GetIconRefFromFile(PyObject *_self, PyObject *_args) 775{ 776 PyObject *_res = NULL; 777 OSErr _err; 778 FSSpec theFile; 779 IconRef theIconRef; 780 SInt16 theLabel; 781#ifndef GetIconRefFromFile 782 PyMac_PRECHECK(GetIconRefFromFile); 783#endif 784 if (!PyArg_ParseTuple(_args, "O&", 785 PyMac_GetFSSpec, &theFile)) 786 return NULL; 787 _err = GetIconRefFromFile(&theFile, 788 &theIconRef, 789 &theLabel); 790 if (_err != noErr) return PyMac_Error(_err); 791 _res = Py_BuildValue("O&h", 792 ResObj_New, theIconRef, 793 theLabel); 794 return _res; 795} 796 797static PyObject *Icn_GetIconRef(PyObject *_self, PyObject *_args) 798{ 799 PyObject *_res = NULL; 800 OSErr _err; 801 SInt16 vRefNum; 802 OSType creator; 803 OSType iconType; 804 IconRef theIconRef; 805#ifndef GetIconRef 806 PyMac_PRECHECK(GetIconRef); 807#endif 808 if (!PyArg_ParseTuple(_args, "hO&O&", 809 &vRefNum, 810 PyMac_GetOSType, &creator, 811 PyMac_GetOSType, &iconType)) 812 return NULL; 813 _err = GetIconRef(vRefNum, 814 creator, 815 iconType, 816 &theIconRef); 817 if (_err != noErr) return PyMac_Error(_err); 818 _res = Py_BuildValue("O&", 819 ResObj_New, theIconRef); 820 return _res; 821} 822 823static PyObject *Icn_GetIconRefFromFolder(PyObject *_self, PyObject *_args) 824{ 825 PyObject *_res = NULL; 826 OSErr _err; 827 SInt16 vRefNum; 828 SInt32 parentFolderID; 829 SInt32 folderID; 830 SInt8 attributes; 831 SInt8 accessPrivileges; 832 IconRef theIconRef; 833#ifndef GetIconRefFromFolder 834 PyMac_PRECHECK(GetIconRefFromFolder); 835#endif 836 if (!PyArg_ParseTuple(_args, "hllbb", 837 &vRefNum, 838 &parentFolderID, 839 &folderID, 840 &attributes, 841 &accessPrivileges)) 842 return NULL; 843 _err = GetIconRefFromFolder(vRefNum, 844 parentFolderID, 845 folderID, 846 attributes, 847 accessPrivileges, 848 &theIconRef); 849 if (_err != noErr) return PyMac_Error(_err); 850 _res = Py_BuildValue("O&", 851 ResObj_New, theIconRef); 852 return _res; 853} 854 855static PyObject *Icn_RegisterIconRefFromIconFamily(PyObject *_self, PyObject *_args) 856{ 857 PyObject *_res = NULL; 858 OSErr _err; 859 OSType creator; 860 OSType iconType; 861 IconFamilyHandle iconFamily; 862 IconRef theIconRef; 863#ifndef RegisterIconRefFromIconFamily 864 PyMac_PRECHECK(RegisterIconRefFromIconFamily); 865#endif 866 if (!PyArg_ParseTuple(_args, "O&O&O&", 867 PyMac_GetOSType, &creator, 868 PyMac_GetOSType, &iconType, 869 ResObj_Convert, &iconFamily)) 870 return NULL; 871 _err = RegisterIconRefFromIconFamily(creator, 872 iconType, 873 iconFamily, 874 &theIconRef); 875 if (_err != noErr) return PyMac_Error(_err); 876 _res = Py_BuildValue("O&", 877 ResObj_New, theIconRef); 878 return _res; 879} 880 881static PyObject *Icn_RegisterIconRefFromResource(PyObject *_self, PyObject *_args) 882{ 883 PyObject *_res = NULL; 884 OSErr _err; 885 OSType creator; 886 OSType iconType; 887 FSSpec resourceFile; 888 SInt16 resourceID; 889 IconRef theIconRef; 890#ifndef RegisterIconRefFromResource 891 PyMac_PRECHECK(RegisterIconRefFromResource); 892#endif 893 if (!PyArg_ParseTuple(_args, "O&O&O&h", 894 PyMac_GetOSType, &creator, 895 PyMac_GetOSType, &iconType, 896 PyMac_GetFSSpec, &resourceFile, 897 &resourceID)) 898 return NULL; 899 _err = RegisterIconRefFromResource(creator, 900 iconType, 901 &resourceFile, 902 resourceID, 903 &theIconRef); 904 if (_err != noErr) return PyMac_Error(_err); 905 _res = Py_BuildValue("O&", 906 ResObj_New, theIconRef); 907 return _res; 908} 909 910static PyObject *Icn_RegisterIconRefFromFSRef(PyObject *_self, PyObject *_args) 911{ 912 PyObject *_res = NULL; 913 OSStatus _err; 914 OSType creator; 915 OSType iconType; 916 FSRef iconFile; 917 IconRef theIconRef; 918#ifndef RegisterIconRefFromFSRef 919 PyMac_PRECHECK(RegisterIconRefFromFSRef); 920#endif 921 if (!PyArg_ParseTuple(_args, "O&O&O&", 922 PyMac_GetOSType, &creator, 923 PyMac_GetOSType, &iconType, 924 PyMac_GetFSRef, &iconFile)) 925 return NULL; 926 _err = RegisterIconRefFromFSRef(creator, 927 iconType, 928 &iconFile, 929 &theIconRef); 930 if (_err != noErr) return PyMac_Error(_err); 931 _res = Py_BuildValue("O&", 932 ResObj_New, theIconRef); 933 return _res; 934} 935 936static PyObject *Icn_UnregisterIconRef(PyObject *_self, PyObject *_args) 937{ 938 PyObject *_res = NULL; 939 OSErr _err; 940 OSType creator; 941 OSType iconType; 942#ifndef UnregisterIconRef 943 PyMac_PRECHECK(UnregisterIconRef); 944#endif 945 if (!PyArg_ParseTuple(_args, "O&O&", 946 PyMac_GetOSType, &creator, 947 PyMac_GetOSType, &iconType)) 948 return NULL; 949 _err = UnregisterIconRef(creator, 950 iconType); 951 if (_err != noErr) return PyMac_Error(_err); 952 Py_INCREF(Py_None); 953 _res = Py_None; 954 return _res; 955} 956 957static PyObject *Icn_UpdateIconRef(PyObject *_self, PyObject *_args) 958{ 959 PyObject *_res = NULL; 960 OSErr _err; 961 IconRef theIconRef; 962#ifndef UpdateIconRef 963 PyMac_PRECHECK(UpdateIconRef); 964#endif 965 if (!PyArg_ParseTuple(_args, "O&", 966 ResObj_Convert, &theIconRef)) 967 return NULL; 968 _err = UpdateIconRef(theIconRef); 969 if (_err != noErr) return PyMac_Error(_err); 970 Py_INCREF(Py_None); 971 _res = Py_None; 972 return _res; 973} 974 975static PyObject *Icn_OverrideIconRefFromResource(PyObject *_self, PyObject *_args) 976{ 977 PyObject *_res = NULL; 978 OSErr _err; 979 IconRef theIconRef; 980 FSSpec resourceFile; 981 SInt16 resourceID; 982#ifndef OverrideIconRefFromResource 983 PyMac_PRECHECK(OverrideIconRefFromResource); 984#endif 985 if (!PyArg_ParseTuple(_args, "O&O&h", 986 ResObj_Convert, &theIconRef, 987 PyMac_GetFSSpec, &resourceFile, 988 &resourceID)) 989 return NULL; 990 _err = OverrideIconRefFromResource(theIconRef, 991 &resourceFile, 992 resourceID); 993 if (_err != noErr) return PyMac_Error(_err); 994 Py_INCREF(Py_None); 995 _res = Py_None; 996 return _res; 997} 998 999static PyObject *Icn_OverrideIconRef(PyObject *_self, PyObject *_args) 1000{ 1001 PyObject *_res = NULL; 1002 OSErr _err; 1003 IconRef oldIconRef; 1004 IconRef newIconRef; 1005#ifndef OverrideIconRef 1006 PyMac_PRECHECK(OverrideIconRef); 1007#endif 1008 if (!PyArg_ParseTuple(_args, "O&O&", 1009 ResObj_Convert, &oldIconRef, 1010 ResObj_Convert, &newIconRef)) 1011 return NULL; 1012 _err = OverrideIconRef(oldIconRef, 1013 newIconRef); 1014 if (_err != noErr) return PyMac_Error(_err); 1015 Py_INCREF(Py_None); 1016 _res = Py_None; 1017 return _res; 1018} 1019 1020static PyObject *Icn_RemoveIconRefOverride(PyObject *_self, PyObject *_args) 1021{ 1022 PyObject *_res = NULL; 1023 OSErr _err; 1024 IconRef theIconRef; 1025#ifndef RemoveIconRefOverride 1026 PyMac_PRECHECK(RemoveIconRefOverride); 1027#endif 1028 if (!PyArg_ParseTuple(_args, "O&", 1029 ResObj_Convert, &theIconRef)) 1030 return NULL; 1031 _err = RemoveIconRefOverride(theIconRef); 1032 if (_err != noErr) return PyMac_Error(_err); 1033 Py_INCREF(Py_None); 1034 _res = Py_None; 1035 return _res; 1036} 1037 1038static PyObject *Icn_CompositeIconRef(PyObject *_self, PyObject *_args) 1039{ 1040 PyObject *_res = NULL; 1041 OSErr _err; 1042 IconRef backgroundIconRef; 1043 IconRef foregroundIconRef; 1044 IconRef compositeIconRef; 1045#ifndef CompositeIconRef 1046 PyMac_PRECHECK(CompositeIconRef); 1047#endif 1048 if (!PyArg_ParseTuple(_args, "O&O&", 1049 ResObj_Convert, &backgroundIconRef, 1050 ResObj_Convert, &foregroundIconRef)) 1051 return NULL; 1052 _err = CompositeIconRef(backgroundIconRef, 1053 foregroundIconRef, 1054 &compositeIconRef); 1055 if (_err != noErr) return PyMac_Error(_err); 1056 _res = Py_BuildValue("O&", 1057 ResObj_New, compositeIconRef); 1058 return _res; 1059} 1060 1061static PyObject *Icn_IsIconRefComposite(PyObject *_self, PyObject *_args) 1062{ 1063 PyObject *_res = NULL; 1064 OSErr _err; 1065 IconRef compositeIconRef; 1066 IconRef backgroundIconRef; 1067 IconRef foregroundIconRef; 1068#ifndef IsIconRefComposite 1069 PyMac_PRECHECK(IsIconRefComposite); 1070#endif 1071 if (!PyArg_ParseTuple(_args, "O&", 1072 ResObj_Convert, &compositeIconRef)) 1073 return NULL; 1074 _err = IsIconRefComposite(compositeIconRef, 1075 &backgroundIconRef, 1076 &foregroundIconRef); 1077 if (_err != noErr) return PyMac_Error(_err); 1078 _res = Py_BuildValue("O&O&", 1079 ResObj_New, backgroundIconRef, 1080 ResObj_New, foregroundIconRef); 1081 return _res; 1082} 1083 1084static PyObject *Icn_IsValidIconRef(PyObject *_self, PyObject *_args) 1085{ 1086 PyObject *_res = NULL; 1087 Boolean _rv; 1088 IconRef theIconRef; 1089#ifndef IsValidIconRef 1090 PyMac_PRECHECK(IsValidIconRef); 1091#endif 1092 if (!PyArg_ParseTuple(_args, "O&", 1093 ResObj_Convert, &theIconRef)) 1094 return NULL; 1095 _rv = IsValidIconRef(theIconRef); 1096 _res = Py_BuildValue("b", 1097 _rv); 1098 return _res; 1099} 1100 1101static PyObject *Icn_PlotIconRef(PyObject *_self, PyObject *_args) 1102{ 1103 PyObject *_res = NULL; 1104 OSErr _err; 1105 Rect theRect; 1106 IconAlignmentType align; 1107 IconTransformType transform; 1108 IconServicesUsageFlags theIconServicesUsageFlags; 1109 IconRef theIconRef; 1110#ifndef PlotIconRef 1111 PyMac_PRECHECK(PlotIconRef); 1112#endif 1113 if (!PyArg_ParseTuple(_args, "O&hhlO&", 1114 PyMac_GetRect, &theRect, 1115 &align, 1116 &transform, 1117 &theIconServicesUsageFlags, 1118 ResObj_Convert, &theIconRef)) 1119 return NULL; 1120 _err = PlotIconRef(&theRect, 1121 align, 1122 transform, 1123 theIconServicesUsageFlags, 1124 theIconRef); 1125 if (_err != noErr) return PyMac_Error(_err); 1126 Py_INCREF(Py_None); 1127 _res = Py_None; 1128 return _res; 1129} 1130 1131static PyObject *Icn_PtInIconRef(PyObject *_self, PyObject *_args) 1132{ 1133 PyObject *_res = NULL; 1134 Boolean _rv; 1135 Point testPt; 1136 Rect iconRect; 1137 IconAlignmentType align; 1138 IconServicesUsageFlags theIconServicesUsageFlags; 1139 IconRef theIconRef; 1140#ifndef PtInIconRef 1141 PyMac_PRECHECK(PtInIconRef); 1142#endif 1143 if (!PyArg_ParseTuple(_args, "O&O&hlO&", 1144 PyMac_GetPoint, &testPt, 1145 PyMac_GetRect, &iconRect, 1146 &align, 1147 &theIconServicesUsageFlags, 1148 ResObj_Convert, &theIconRef)) 1149 return NULL; 1150 _rv = PtInIconRef(&testPt, 1151 &iconRect, 1152 align, 1153 theIconServicesUsageFlags, 1154 theIconRef); 1155 _res = Py_BuildValue("b", 1156 _rv); 1157 return _res; 1158} 1159 1160static PyObject *Icn_RectInIconRef(PyObject *_self, PyObject *_args) 1161{ 1162 PyObject *_res = NULL; 1163 Boolean _rv; 1164 Rect testRect; 1165 Rect iconRect; 1166 IconAlignmentType align; 1167 IconServicesUsageFlags iconServicesUsageFlags; 1168 IconRef theIconRef; 1169#ifndef RectInIconRef 1170 PyMac_PRECHECK(RectInIconRef); 1171#endif 1172 if (!PyArg_ParseTuple(_args, "O&O&hlO&", 1173 PyMac_GetRect, &testRect, 1174 PyMac_GetRect, &iconRect, 1175 &align, 1176 &iconServicesUsageFlags, 1177 ResObj_Convert, &theIconRef)) 1178 return NULL; 1179 _rv = RectInIconRef(&testRect, 1180 &iconRect, 1181 align, 1182 iconServicesUsageFlags, 1183 theIconRef); 1184 _res = Py_BuildValue("b", 1185 _rv); 1186 return _res; 1187} 1188 1189static PyObject *Icn_IconRefToRgn(PyObject *_self, PyObject *_args) 1190{ 1191 PyObject *_res = NULL; 1192 OSErr _err; 1193 RgnHandle theRgn; 1194 Rect iconRect; 1195 IconAlignmentType align; 1196 IconServicesUsageFlags iconServicesUsageFlags; 1197 IconRef theIconRef; 1198#ifndef IconRefToRgn 1199 PyMac_PRECHECK(IconRefToRgn); 1200#endif 1201 if (!PyArg_ParseTuple(_args, "O&O&hlO&", 1202 ResObj_Convert, &theRgn, 1203 PyMac_GetRect, &iconRect, 1204 &align, 1205 &iconServicesUsageFlags, 1206 ResObj_Convert, &theIconRef)) 1207 return NULL; 1208 _err = IconRefToRgn(theRgn, 1209 &iconRect, 1210 align, 1211 iconServicesUsageFlags, 1212 theIconRef); 1213 if (_err != noErr) return PyMac_Error(_err); 1214 Py_INCREF(Py_None); 1215 _res = Py_None; 1216 return _res; 1217} 1218 1219static PyObject *Icn_GetIconSizesFromIconRef(PyObject *_self, PyObject *_args) 1220{ 1221 PyObject *_res = NULL; 1222 OSErr _err; 1223 IconSelectorValue iconSelectorInput; 1224 IconSelectorValue iconSelectorOutputPtr; 1225 IconServicesUsageFlags iconServicesUsageFlags; 1226 IconRef theIconRef; 1227#ifndef GetIconSizesFromIconRef 1228 PyMac_PRECHECK(GetIconSizesFromIconRef); 1229#endif 1230 if (!PyArg_ParseTuple(_args, "llO&", 1231 &iconSelectorInput, 1232 &iconServicesUsageFlags, 1233 ResObj_Convert, &theIconRef)) 1234 return NULL; 1235 _err = GetIconSizesFromIconRef(iconSelectorInput, 1236 &iconSelectorOutputPtr, 1237 iconServicesUsageFlags, 1238 theIconRef); 1239 if (_err != noErr) return PyMac_Error(_err); 1240 _res = Py_BuildValue("l", 1241 iconSelectorOutputPtr); 1242 return _res; 1243} 1244 1245static PyObject *Icn_FlushIconRefs(PyObject *_self, PyObject *_args) 1246{ 1247 PyObject *_res = NULL; 1248 OSErr _err; 1249 OSType creator; 1250 OSType iconType; 1251#ifndef FlushIconRefs 1252 PyMac_PRECHECK(FlushIconRefs); 1253#endif 1254 if (!PyArg_ParseTuple(_args, "O&O&", 1255 PyMac_GetOSType, &creator, 1256 PyMac_GetOSType, &iconType)) 1257 return NULL; 1258 _err = FlushIconRefs(creator, 1259 iconType); 1260 if (_err != noErr) return PyMac_Error(_err); 1261 Py_INCREF(Py_None); 1262 _res = Py_None; 1263 return _res; 1264} 1265 1266static PyObject *Icn_FlushIconRefsByVolume(PyObject *_self, PyObject *_args) 1267{ 1268 PyObject *_res = NULL; 1269 OSErr _err; 1270 SInt16 vRefNum; 1271#ifndef FlushIconRefsByVolume 1272 PyMac_PRECHECK(FlushIconRefsByVolume); 1273#endif 1274 if (!PyArg_ParseTuple(_args, "h", 1275 &vRefNum)) 1276 return NULL; 1277 _err = FlushIconRefsByVolume(vRefNum); 1278 if (_err != noErr) return PyMac_Error(_err); 1279 Py_INCREF(Py_None); 1280 _res = Py_None; 1281 return _res; 1282} 1283 1284static PyObject *Icn_SetCustomIconsEnabled(PyObject *_self, PyObject *_args) 1285{ 1286 PyObject *_res = NULL; 1287 OSErr _err; 1288 SInt16 vRefNum; 1289 Boolean enableCustomIcons; 1290#ifndef SetCustomIconsEnabled 1291 PyMac_PRECHECK(SetCustomIconsEnabled); 1292#endif 1293 if (!PyArg_ParseTuple(_args, "hb", 1294 &vRefNum, 1295 &enableCustomIcons)) 1296 return NULL; 1297 _err = SetCustomIconsEnabled(vRefNum, 1298 enableCustomIcons); 1299 if (_err != noErr) return PyMac_Error(_err); 1300 Py_INCREF(Py_None); 1301 _res = Py_None; 1302 return _res; 1303} 1304 1305static PyObject *Icn_GetCustomIconsEnabled(PyObject *_self, PyObject *_args) 1306{ 1307 PyObject *_res = NULL; 1308 OSErr _err; 1309 SInt16 vRefNum; 1310 Boolean customIconsEnabled; 1311#ifndef GetCustomIconsEnabled 1312 PyMac_PRECHECK(GetCustomIconsEnabled); 1313#endif 1314 if (!PyArg_ParseTuple(_args, "h", 1315 &vRefNum)) 1316 return NULL; 1317 _err = GetCustomIconsEnabled(vRefNum, 1318 &customIconsEnabled); 1319 if (_err != noErr) return PyMac_Error(_err); 1320 _res = Py_BuildValue("b", 1321 customIconsEnabled); 1322 return _res; 1323} 1324 1325static PyObject *Icn_IsIconRefMaskEmpty(PyObject *_self, PyObject *_args) 1326{ 1327 PyObject *_res = NULL; 1328 Boolean _rv; 1329 IconRef iconRef; 1330#ifndef IsIconRefMaskEmpty 1331 PyMac_PRECHECK(IsIconRefMaskEmpty); 1332#endif 1333 if (!PyArg_ParseTuple(_args, "O&", 1334 ResObj_Convert, &iconRef)) 1335 return NULL; 1336 _rv = IsIconRefMaskEmpty(iconRef); 1337 _res = Py_BuildValue("b", 1338 _rv); 1339 return _res; 1340} 1341 1342static PyObject *Icn_GetIconRefVariant(PyObject *_self, PyObject *_args) 1343{ 1344 PyObject *_res = NULL; 1345 IconRef _rv; 1346 IconRef inIconRef; 1347 OSType inVariant; 1348 IconTransformType outTransform; 1349#ifndef GetIconRefVariant 1350 PyMac_PRECHECK(GetIconRefVariant); 1351#endif 1352 if (!PyArg_ParseTuple(_args, "O&O&", 1353 ResObj_Convert, &inIconRef, 1354 PyMac_GetOSType, &inVariant)) 1355 return NULL; 1356 _rv = GetIconRefVariant(inIconRef, 1357 inVariant, 1358 &outTransform); 1359 _res = Py_BuildValue("O&h", 1360 ResObj_New, _rv, 1361 outTransform); 1362 return _res; 1363} 1364 1365static PyObject *Icn_RegisterIconRefFromIconFile(PyObject *_self, PyObject *_args) 1366{ 1367 PyObject *_res = NULL; 1368 OSErr _err; 1369 OSType creator; 1370 OSType iconType; 1371 FSSpec iconFile; 1372 IconRef theIconRef; 1373#ifndef RegisterIconRefFromIconFile 1374 PyMac_PRECHECK(RegisterIconRefFromIconFile); 1375#endif 1376 if (!PyArg_ParseTuple(_args, "O&O&O&", 1377 PyMac_GetOSType, &creator, 1378 PyMac_GetOSType, &iconType, 1379 PyMac_GetFSSpec, &iconFile)) 1380 return NULL; 1381 _err = RegisterIconRefFromIconFile(creator, 1382 iconType, 1383 &iconFile, 1384 &theIconRef); 1385 if (_err != noErr) return PyMac_Error(_err); 1386 _res = Py_BuildValue("O&", 1387 ResObj_New, theIconRef); 1388 return _res; 1389} 1390 1391static PyObject *Icn_ReadIconFile(PyObject *_self, PyObject *_args) 1392{ 1393 PyObject *_res = NULL; 1394 OSErr _err; 1395 FSSpec iconFile; 1396 IconFamilyHandle iconFamily; 1397#ifndef ReadIconFile 1398 PyMac_PRECHECK(ReadIconFile); 1399#endif 1400 if (!PyArg_ParseTuple(_args, "O&", 1401 PyMac_GetFSSpec, &iconFile)) 1402 return NULL; 1403 _err = ReadIconFile(&iconFile, 1404 &iconFamily); 1405 if (_err != noErr) return PyMac_Error(_err); 1406 _res = Py_BuildValue("O&", 1407 ResObj_New, iconFamily); 1408 return _res; 1409} 1410 1411static PyObject *Icn_ReadIconFromFSRef(PyObject *_self, PyObject *_args) 1412{ 1413 PyObject *_res = NULL; 1414 OSStatus _err; 1415 FSRef ref; 1416 IconFamilyHandle iconFamily; 1417#ifndef ReadIconFromFSRef 1418 PyMac_PRECHECK(ReadIconFromFSRef); 1419#endif 1420 if (!PyArg_ParseTuple(_args, "O&", 1421 PyMac_GetFSRef, &ref)) 1422 return NULL; 1423 _err = ReadIconFromFSRef(&ref, 1424 &iconFamily); 1425 if (_err != noErr) return PyMac_Error(_err); 1426 _res = Py_BuildValue("O&", 1427 ResObj_New, iconFamily); 1428 return _res; 1429} 1430 1431static PyObject *Icn_WriteIconFile(PyObject *_self, PyObject *_args) 1432{ 1433 PyObject *_res = NULL; 1434 OSErr _err; 1435 IconFamilyHandle iconFamily; 1436 FSSpec iconFile; 1437#ifndef WriteIconFile 1438 PyMac_PRECHECK(WriteIconFile); 1439#endif 1440 if (!PyArg_ParseTuple(_args, "O&O&", 1441 ResObj_Convert, &iconFamily, 1442 PyMac_GetFSSpec, &iconFile)) 1443 return NULL; 1444 _err = WriteIconFile(iconFamily, 1445 &iconFile); 1446 if (_err != noErr) return PyMac_Error(_err); 1447 Py_INCREF(Py_None); 1448 _res = Py_None; 1449 return _res; 1450} 1451#endif /* __LP64__ */ 1452 1453static PyMethodDef Icn_methods[] = { 1454#ifndef __LP64__ 1455 {"GetCIcon", (PyCFunction)Icn_GetCIcon, 1, 1456 PyDoc_STR("(SInt16 iconID) -> (CIconHandle _rv)")}, 1457 {"PlotCIcon", (PyCFunction)Icn_PlotCIcon, 1, 1458 PyDoc_STR("(Rect theRect, CIconHandle theIcon) -> None")}, 1459 {"DisposeCIcon", (PyCFunction)Icn_DisposeCIcon, 1, 1460 PyDoc_STR("(CIconHandle theIcon) -> None")}, 1461 {"GetIcon", (PyCFunction)Icn_GetIcon, 1, 1462 PyDoc_STR("(SInt16 iconID) -> (Handle _rv)")}, 1463 {"PlotIcon", (PyCFunction)Icn_PlotIcon, 1, 1464 PyDoc_STR("(Rect theRect, Handle theIcon) -> None")}, 1465 {"PlotIconID", (PyCFunction)Icn_PlotIconID, 1, 1466 PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, SInt16 theResID) -> None")}, 1467 {"NewIconSuite", (PyCFunction)Icn_NewIconSuite, 1, 1468 PyDoc_STR("() -> (IconSuiteRef theIconSuite)")}, 1469 {"AddIconToSuite", (PyCFunction)Icn_AddIconToSuite, 1, 1470 PyDoc_STR("(Handle theIconData, IconSuiteRef theSuite, ResType theType) -> None")}, 1471 {"GetIconFromSuite", (PyCFunction)Icn_GetIconFromSuite, 1, 1472 PyDoc_STR("(IconSuiteRef theSuite, ResType theType) -> (Handle theIconData)")}, 1473 {"GetIconSuite", (PyCFunction)Icn_GetIconSuite, 1, 1474 PyDoc_STR("(SInt16 theResID, IconSelectorValue selector) -> (IconSuiteRef theIconSuite)")}, 1475 {"DisposeIconSuite", (PyCFunction)Icn_DisposeIconSuite, 1, 1476 PyDoc_STR("(IconSuiteRef theIconSuite, Boolean disposeData) -> None")}, 1477 {"PlotIconSuite", (PyCFunction)Icn_PlotIconSuite, 1, 1478 PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconSuiteRef theIconSuite) -> None")}, 1479 {"LoadIconCache", (PyCFunction)Icn_LoadIconCache, 1, 1480 PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconCacheRef theIconCache) -> None")}, 1481 {"GetLabel", (PyCFunction)Icn_GetLabel, 1, 1482 PyDoc_STR("(SInt16 labelNumber, Str255 labelString) -> (RGBColor labelColor)")}, 1483 {"PtInIconID", (PyCFunction)Icn_PtInIconID, 1, 1484 PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)")}, 1485 {"PtInIconSuite", (PyCFunction)Icn_PtInIconSuite, 1, 1486 PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)")}, 1487 {"RectInIconID", (PyCFunction)Icn_RectInIconID, 1, 1488 PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)")}, 1489 {"RectInIconSuite", (PyCFunction)Icn_RectInIconSuite, 1, 1490 PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)")}, 1491 {"IconIDToRgn", (PyCFunction)Icn_IconIDToRgn, 1, 1492 PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> None")}, 1493 {"IconSuiteToRgn", (PyCFunction)Icn_IconSuiteToRgn, 1, 1494 PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> None")}, 1495 {"SetSuiteLabel", (PyCFunction)Icn_SetSuiteLabel, 1, 1496 PyDoc_STR("(IconSuiteRef theSuite, SInt16 theLabel) -> None")}, 1497 {"GetSuiteLabel", (PyCFunction)Icn_GetSuiteLabel, 1, 1498 PyDoc_STR("(IconSuiteRef theSuite) -> (SInt16 _rv)")}, 1499 {"PlotIconHandle", (PyCFunction)Icn_PlotIconHandle, 1, 1500 PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theIcon) -> None")}, 1501 {"PlotSICNHandle", (PyCFunction)Icn_PlotSICNHandle, 1, 1502 PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theSICN) -> None")}, 1503 {"PlotCIconHandle", (PyCFunction)Icn_PlotCIconHandle, 1, 1504 PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, CIconHandle theCIcon) -> None")}, 1505 {"IconRefToIconFamily", (PyCFunction)Icn_IconRefToIconFamily, 1, 1506 PyDoc_STR("(IconRef theIconRef, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)")}, 1507 {"IconFamilyToIconSuite", (PyCFunction)Icn_IconFamilyToIconSuite, 1, 1508 PyDoc_STR("(IconFamilyHandle iconFamily, IconSelectorValue whichIcons) -> (IconSuiteRef iconSuite)")}, 1509 {"IconSuiteToIconFamily", (PyCFunction)Icn_IconSuiteToIconFamily, 1, 1510 PyDoc_STR("(IconSuiteRef iconSuite, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)")}, 1511 {"SetIconFamilyData", (PyCFunction)Icn_SetIconFamilyData, 1, 1512 PyDoc_STR("(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None")}, 1513 {"GetIconFamilyData", (PyCFunction)Icn_GetIconFamilyData, 1, 1514 PyDoc_STR("(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None")}, 1515 {"GetIconRefOwners", (PyCFunction)Icn_GetIconRefOwners, 1, 1516 PyDoc_STR("(IconRef theIconRef) -> (UInt16 owners)")}, 1517 {"AcquireIconRef", (PyCFunction)Icn_AcquireIconRef, 1, 1518 PyDoc_STR("(IconRef theIconRef) -> None")}, 1519 {"ReleaseIconRef", (PyCFunction)Icn_ReleaseIconRef, 1, 1520 PyDoc_STR("(IconRef theIconRef) -> None")}, 1521 {"GetIconRefFromFile", (PyCFunction)Icn_GetIconRefFromFile, 1, 1522 PyDoc_STR("(FSSpec theFile) -> (IconRef theIconRef, SInt16 theLabel)")}, 1523 {"GetIconRef", (PyCFunction)Icn_GetIconRef, 1, 1524 PyDoc_STR("(SInt16 vRefNum, OSType creator, OSType iconType) -> (IconRef theIconRef)")}, 1525 {"GetIconRefFromFolder", (PyCFunction)Icn_GetIconRefFromFolder, 1, 1526 PyDoc_STR("(SInt16 vRefNum, SInt32 parentFolderID, SInt32 folderID, SInt8 attributes, SInt8 accessPrivileges) -> (IconRef theIconRef)")}, 1527 {"RegisterIconRefFromIconFamily", (PyCFunction)Icn_RegisterIconRefFromIconFamily, 1, 1528 PyDoc_STR("(OSType creator, OSType iconType, IconFamilyHandle iconFamily) -> (IconRef theIconRef)")}, 1529 {"RegisterIconRefFromResource", (PyCFunction)Icn_RegisterIconRefFromResource, 1, 1530 PyDoc_STR("(OSType creator, OSType iconType, FSSpec resourceFile, SInt16 resourceID) -> (IconRef theIconRef)")}, 1531 {"RegisterIconRefFromFSRef", (PyCFunction)Icn_RegisterIconRefFromFSRef, 1, 1532 PyDoc_STR("(OSType creator, OSType iconType, FSRef iconFile) -> (IconRef theIconRef)")}, 1533 {"UnregisterIconRef", (PyCFunction)Icn_UnregisterIconRef, 1, 1534 PyDoc_STR("(OSType creator, OSType iconType) -> None")}, 1535 {"UpdateIconRef", (PyCFunction)Icn_UpdateIconRef, 1, 1536 PyDoc_STR("(IconRef theIconRef) -> None")}, 1537 {"OverrideIconRefFromResource", (PyCFunction)Icn_OverrideIconRefFromResource, 1, 1538 PyDoc_STR("(IconRef theIconRef, FSSpec resourceFile, SInt16 resourceID) -> None")}, 1539 {"OverrideIconRef", (PyCFunction)Icn_OverrideIconRef, 1, 1540 PyDoc_STR("(IconRef oldIconRef, IconRef newIconRef) -> None")}, 1541 {"RemoveIconRefOverride", (PyCFunction)Icn_RemoveIconRefOverride, 1, 1542 PyDoc_STR("(IconRef theIconRef) -> None")}, 1543 {"CompositeIconRef", (PyCFunction)Icn_CompositeIconRef, 1, 1544 PyDoc_STR("(IconRef backgroundIconRef, IconRef foregroundIconRef) -> (IconRef compositeIconRef)")}, 1545 {"IsIconRefComposite", (PyCFunction)Icn_IsIconRefComposite, 1, 1546 PyDoc_STR("(IconRef compositeIconRef) -> (IconRef backgroundIconRef, IconRef foregroundIconRef)")}, 1547 {"IsValidIconRef", (PyCFunction)Icn_IsValidIconRef, 1, 1548 PyDoc_STR("(IconRef theIconRef) -> (Boolean _rv)")}, 1549 {"PlotIconRef", (PyCFunction)Icn_PlotIconRef, 1, 1550 PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> None")}, 1551 {"PtInIconRef", (PyCFunction)Icn_PtInIconRef, 1, 1552 PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)")}, 1553 {"RectInIconRef", (PyCFunction)Icn_RectInIconRef, 1, 1554 PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)")}, 1555 {"IconRefToRgn", (PyCFunction)Icn_IconRefToRgn, 1, 1556 PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> None")}, 1557 {"GetIconSizesFromIconRef", (PyCFunction)Icn_GetIconSizesFromIconRef, 1, 1558 PyDoc_STR("(IconSelectorValue iconSelectorInput, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (IconSelectorValue iconSelectorOutputPtr)")}, 1559 {"FlushIconRefs", (PyCFunction)Icn_FlushIconRefs, 1, 1560 PyDoc_STR("(OSType creator, OSType iconType) -> None")}, 1561 {"FlushIconRefsByVolume", (PyCFunction)Icn_FlushIconRefsByVolume, 1, 1562 PyDoc_STR("(SInt16 vRefNum) -> None")}, 1563 {"SetCustomIconsEnabled", (PyCFunction)Icn_SetCustomIconsEnabled, 1, 1564 PyDoc_STR("(SInt16 vRefNum, Boolean enableCustomIcons) -> None")}, 1565 {"GetCustomIconsEnabled", (PyCFunction)Icn_GetCustomIconsEnabled, 1, 1566 PyDoc_STR("(SInt16 vRefNum) -> (Boolean customIconsEnabled)")}, 1567 {"IsIconRefMaskEmpty", (PyCFunction)Icn_IsIconRefMaskEmpty, 1, 1568 PyDoc_STR("(IconRef iconRef) -> (Boolean _rv)")}, 1569 {"GetIconRefVariant", (PyCFunction)Icn_GetIconRefVariant, 1, 1570 PyDoc_STR("(IconRef inIconRef, OSType inVariant) -> (IconRef _rv, IconTransformType outTransform)")}, 1571 {"RegisterIconRefFromIconFile", (PyCFunction)Icn_RegisterIconRefFromIconFile, 1, 1572 PyDoc_STR("(OSType creator, OSType iconType, FSSpec iconFile) -> (IconRef theIconRef)")}, 1573 {"ReadIconFile", (PyCFunction)Icn_ReadIconFile, 1, 1574 PyDoc_STR("(FSSpec iconFile) -> (IconFamilyHandle iconFamily)")}, 1575 {"ReadIconFromFSRef", (PyCFunction)Icn_ReadIconFromFSRef, 1, 1576 PyDoc_STR("(FSRef ref) -> (IconFamilyHandle iconFamily)")}, 1577 {"WriteIconFile", (PyCFunction)Icn_WriteIconFile, 1, 1578 PyDoc_STR("(IconFamilyHandle iconFamily, FSSpec iconFile) -> None")}, 1579#endif /* __LP64__ */ 1580 {NULL, NULL, 0} 1581}; 1582 1583 1584 1585 1586void init_Icn(void) 1587{ 1588 PyObject *m; 1589#ifndef __LP64__ 1590 PyObject *d; 1591#endif /* __LP64__ */ 1592 1593 1594 1595 1596 m = Py_InitModule("_Icn", Icn_methods); 1597#ifndef __LP64__ 1598 d = PyModule_GetDict(m); 1599 Icn_Error = PyMac_GetOSErrException(); 1600 if (Icn_Error == NULL || 1601 PyDict_SetItemString(d, "Error", Icn_Error) != 0) 1602 return; 1603#endif /* __LP64__ */ 1604} 1605 1606/* ======================== End module _Icn ========================= */ 1607