PageRenderTime 146ms CodeModel.GetById 11ms app.highlight 121ms RepoModel.GetById 1ms app.codeStats 1ms

/Mac/Modules/icn/_Icnmodule.c

http://unladen-swallow.googlecode.com/
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