← Back to branch summary

~malept/ubuntu/lucid/python2.6/dev-dependency-fix

« back to all changes in this revision

Viewing changes to Mac/Modules/icn/_Icnmodule.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-02-13 12:51:00 UTC
  • Revision ID: james.westby@ubuntu.com-20090213125100-uufgcb9yeqzujpqw
Tags: upstream-2.6.1
Import upstream version 2.6.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Mac/Modules/icn/_Icnmodule.c
 
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
 
 
22
static PyObject *Icn_Error;
 
23
 
 
24
static 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
 
 
41
static 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
 
 
60
static 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
 
 
76
static 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
 
 
93
static 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
 
 
112
static 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
 
 
139
static 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
 
 
156
static 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
 
 
180
static 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
 
 
203
static 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
 
 
226
static 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
 
 
247
static 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
 
 
274
static 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
 
 
301
static 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
 
 
324
static 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
 
 
350
static 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
 
 
376
static 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
 
 
402
static 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
 
 
428
static 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
 
 
455
static 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
 
 
482
static 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
 
 
503
static 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
 
 
520
static 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
 
 
547
static 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
 
 
574
static 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
 
 
601
static 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
 
 
624
static 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
 
 
647
static 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
 
 
670
static 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
 
 
694
static 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
 
 
718
static 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
 
 
738
static 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
 
 
756
static 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
 
 
774
static 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
 
 
797
static 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
 
 
823
static 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
 
 
855
static 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
 
 
881
static 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
 
 
910
static 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
 
 
936
static 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
 
 
957
static 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
 
 
975
static 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
 
 
999
static 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
 
 
1020
static 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
 
 
1038
static 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
 
 
1061
static 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
 
 
1084
static 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
 
 
1101
static 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
 
 
1131
static 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
 
 
1160
static 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
 
 
1189
static 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
 
 
1219
static 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
 
 
1245
static 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
 
 
1266
static 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
 
 
1284
static 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
 
 
1305
static 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
 
 
1325
static 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
 
 
1342
static 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
 
 
1365
static 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
 
 
1391
static 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
 
 
1411
static 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
 
 
1431
static 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
 
 
1453
static 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
 
 
1586
void 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