source: python/trunk/Mac/Modules/icn/_Icnmodule.c

Last change on this file was 391, checked in by dmik, 11 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 51.2 KB
Line 
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
Note: See TracBrowser for help on using the repository browser.