← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Mac/Modules/ae/_AEmodule.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/ae/_AEmodule.c
 
1
 
 
2
/* =========================== Module _AE =========================== */
 
3
 
 
4
#include "Python.h"
 
5
 
 
6
 
 
7
 
 
8
#include "pymactoolbox.h"
 
9
 
 
10
#ifndef HAVE_OSX105_SDK
 
11
typedef SInt32 SRefCon;
 
12
#endif
 
13
 
 
14
/* Macro to test whether a weak-loaded CFM function exists */
 
15
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
 
16
        PyErr_SetString(PyExc_NotImplementedError, \
 
17
        "Not available in this shared library/OS version"); \
 
18
        return NULL; \
 
19
    }} while(0)
 
20
 
 
21
 
 
22
#include <Carbon/Carbon.h>
 
23
 
 
24
#ifdef USE_TOOLBOX_OBJECT_GLUE
 
25
extern PyObject *_AEDesc_New(AEDesc *);
 
26
extern int _AEDesc_Convert(PyObject *, AEDesc *);
 
27
 
 
28
#define AEDesc_New _AEDesc_New
 
29
#define AEDesc_NewBorrowed _AEDesc_NewBorrowed
 
30
#define AEDesc_Convert _AEDesc_Convert
 
31
#endif
 
32
 
 
33
typedef long refcontype;
 
34
 
 
35
static pascal OSErr GenericEventHandler(const AppleEvent *request, AppleEvent *reply, refcontype refcon); /* Forward */
 
36
 
 
37
AEEventHandlerUPP upp_GenericEventHandler;
 
38
 
 
39
static pascal Boolean AEIdleProc(EventRecord *theEvent, long *sleepTime, RgnHandle *mouseRgn)
 
40
{
 
41
        if ( PyOS_InterruptOccurred() )
 
42
                return 1;
 
43
        return 0;
 
44
}
 
45
 
 
46
AEIdleUPP upp_AEIdleProc;
 
47
 
 
48
static PyObject *AE_Error;
 
49
 
 
50
/* ----------------------- Object type AEDesc ----------------------- */
 
51
 
 
52
PyTypeObject AEDesc_Type;
 
53
 
 
54
#define AEDesc_Check(x) ((x)->ob_type == &AEDesc_Type || PyObject_TypeCheck((x), &AEDesc_Type))
 
55
 
 
56
typedef struct AEDescObject {
 
57
        PyObject_HEAD
 
58
        AEDesc ob_itself;
 
59
        int ob_owned;
 
60
} AEDescObject;
 
61
 
 
62
PyObject *AEDesc_New(AEDesc *itself)
 
63
{
 
64
        AEDescObject *it;
 
65
        it = PyObject_NEW(AEDescObject, &AEDesc_Type);
 
66
        if (it == NULL) return NULL;
 
67
        it->ob_itself = *itself;
 
68
        it->ob_owned = 1;
 
69
        return (PyObject *)it;
 
70
}
 
71
 
 
72
int AEDesc_Convert(PyObject *v, AEDesc *p_itself)
 
73
{
 
74
        if (!AEDesc_Check(v))
 
75
        {
 
76
                PyErr_SetString(PyExc_TypeError, "AEDesc required");
 
77
                return 0;
 
78
        }
 
79
        *p_itself = ((AEDescObject *)v)->ob_itself;
 
80
        return 1;
 
81
}
 
82
 
 
83
static void AEDesc_dealloc(AEDescObject *self)
 
84
{
 
85
        if (self->ob_owned) AEDisposeDesc(&self->ob_itself);
 
86
        self->ob_type->tp_free((PyObject *)self);
 
87
}
 
88
 
 
89
static PyObject *AEDesc_AECoerceDesc(AEDescObject *_self, PyObject *_args)
 
90
{
 
91
        PyObject *_res = NULL;
 
92
        OSErr _err;
 
93
        DescType toType;
 
94
        AEDesc result;
 
95
#ifndef AECoerceDesc
 
96
        PyMac_PRECHECK(AECoerceDesc);
 
97
#endif
 
98
        if (!PyArg_ParseTuple(_args, "O&",
 
99
                              PyMac_GetOSType, &toType))
 
100
                return NULL;
 
101
        _err = AECoerceDesc(&_self->ob_itself,
 
102
                            toType,
 
103
                            &result);
 
104
        if (_err != noErr) return PyMac_Error(_err);
 
105
        _res = Py_BuildValue("O&",
 
106
                             AEDesc_New, &result);
 
107
        return _res;
 
108
}
 
109
 
 
110
static PyObject *AEDesc_AEDuplicateDesc(AEDescObject *_self, PyObject *_args)
 
111
{
 
112
        PyObject *_res = NULL;
 
113
        OSErr _err;
 
114
        AEDesc result;
 
115
#ifndef AEDuplicateDesc
 
116
        PyMac_PRECHECK(AEDuplicateDesc);
 
117
#endif
 
118
        if (!PyArg_ParseTuple(_args, ""))
 
119
                return NULL;
 
120
        _err = AEDuplicateDesc(&_self->ob_itself,
 
121
                               &result);
 
122
        if (_err != noErr) return PyMac_Error(_err);
 
123
        _res = Py_BuildValue("O&",
 
124
                             AEDesc_New, &result);
 
125
        return _res;
 
126
}
 
127
 
 
128
static PyObject *AEDesc_AECountItems(AEDescObject *_self, PyObject *_args)
 
129
{
 
130
        PyObject *_res = NULL;
 
131
        OSErr _err;
 
132
        long theCount;
 
133
#ifndef AECountItems
 
134
        PyMac_PRECHECK(AECountItems);
 
135
#endif
 
136
        if (!PyArg_ParseTuple(_args, ""))
 
137
                return NULL;
 
138
        _err = AECountItems(&_self->ob_itself,
 
139
                            &theCount);
 
140
        if (_err != noErr) return PyMac_Error(_err);
 
141
        _res = Py_BuildValue("l",
 
142
                             theCount);
 
143
        return _res;
 
144
}
 
145
 
 
146
static PyObject *AEDesc_AEPutPtr(AEDescObject *_self, PyObject *_args)
 
147
{
 
148
        PyObject *_res = NULL;
 
149
        OSErr _err;
 
150
        long index;
 
151
        DescType typeCode;
 
152
        char *dataPtr__in__;
 
153
        long dataPtr__len__;
 
154
        int dataPtr__in_len__;
 
155
#ifndef AEPutPtr
 
156
        PyMac_PRECHECK(AEPutPtr);
 
157
#endif
 
158
        if (!PyArg_ParseTuple(_args, "lO&s#",
 
159
                              &index,
 
160
                              PyMac_GetOSType, &typeCode,
 
161
                              &dataPtr__in__, &dataPtr__in_len__))
 
162
                return NULL;
 
163
        dataPtr__len__ = dataPtr__in_len__;
 
164
        _err = AEPutPtr(&_self->ob_itself,
 
165
                        index,
 
166
                        typeCode,
 
167
                        dataPtr__in__, dataPtr__len__);
 
168
        if (_err != noErr) return PyMac_Error(_err);
 
169
        Py_INCREF(Py_None);
 
170
        _res = Py_None;
 
171
        return _res;
 
172
}
 
173
 
 
174
static PyObject *AEDesc_AEPutDesc(AEDescObject *_self, PyObject *_args)
 
175
{
 
176
        PyObject *_res = NULL;
 
177
        OSErr _err;
 
178
        long index;
 
179
        AEDesc theAEDesc;
 
180
#ifndef AEPutDesc
 
181
        PyMac_PRECHECK(AEPutDesc);
 
182
#endif
 
183
        if (!PyArg_ParseTuple(_args, "lO&",
 
184
                              &index,
 
185
                              AEDesc_Convert, &theAEDesc))
 
186
                return NULL;
 
187
        _err = AEPutDesc(&_self->ob_itself,
 
188
                         index,
 
189
                         &theAEDesc);
 
190
        if (_err != noErr) return PyMac_Error(_err);
 
191
        Py_INCREF(Py_None);
 
192
        _res = Py_None;
 
193
        return _res;
 
194
}
 
195
 
 
196
static PyObject *AEDesc_AEGetNthPtr(AEDescObject *_self, PyObject *_args)
 
197
{
 
198
        PyObject *_res = NULL;
 
199
        OSErr _err;
 
200
        long index;
 
201
        DescType desiredType;
 
202
        AEKeyword theAEKeyword;
 
203
        DescType typeCode;
 
204
        char *dataPtr__out__;
 
205
        long dataPtr__len__;
 
206
        int dataPtr__in_len__;
 
207
#ifndef AEGetNthPtr
 
208
        PyMac_PRECHECK(AEGetNthPtr);
 
209
#endif
 
210
        if (!PyArg_ParseTuple(_args, "lO&i",
 
211
                              &index,
 
212
                              PyMac_GetOSType, &desiredType,
 
213
                              &dataPtr__in_len__))
 
214
                return NULL;
 
215
        if ((dataPtr__out__ = malloc(dataPtr__in_len__)) == NULL)
 
216
        {
 
217
                PyErr_NoMemory();
 
218
                goto dataPtr__error__;
 
219
        }
 
220
        dataPtr__len__ = dataPtr__in_len__;
 
221
        _err = AEGetNthPtr(&_self->ob_itself,
 
222
                           index,
 
223
                           desiredType,
 
224
                           &theAEKeyword,
 
225
                           &typeCode,
 
226
                           dataPtr__out__, dataPtr__len__, &dataPtr__len__);
 
227
        if (_err != noErr) return PyMac_Error(_err);
 
228
        _res = Py_BuildValue("O&O&s#",
 
229
                             PyMac_BuildOSType, theAEKeyword,
 
230
                             PyMac_BuildOSType, typeCode,
 
231
                             dataPtr__out__, (int)dataPtr__len__);
 
232
        free(dataPtr__out__);
 
233
 dataPtr__error__: ;
 
234
        return _res;
 
235
}
 
236
 
 
237
static PyObject *AEDesc_AEGetNthDesc(AEDescObject *_self, PyObject *_args)
 
238
{
 
239
        PyObject *_res = NULL;
 
240
        OSErr _err;
 
241
        long index;
 
242
        DescType desiredType;
 
243
        AEKeyword theAEKeyword;
 
244
        AEDesc result;
 
245
#ifndef AEGetNthDesc
 
246
        PyMac_PRECHECK(AEGetNthDesc);
 
247
#endif
 
248
        if (!PyArg_ParseTuple(_args, "lO&",
 
249
                              &index,
 
250
                              PyMac_GetOSType, &desiredType))
 
251
                return NULL;
 
252
        _err = AEGetNthDesc(&_self->ob_itself,
 
253
                            index,
 
254
                            desiredType,
 
255
                            &theAEKeyword,
 
256
                            &result);
 
257
        if (_err != noErr) return PyMac_Error(_err);
 
258
        _res = Py_BuildValue("O&O&",
 
259
                             PyMac_BuildOSType, theAEKeyword,
 
260
                             AEDesc_New, &result);
 
261
        return _res;
 
262
}
 
263
 
 
264
static PyObject *AEDesc_AESizeOfNthItem(AEDescObject *_self, PyObject *_args)
 
265
{
 
266
        PyObject *_res = NULL;
 
267
        OSErr _err;
 
268
        long index;
 
269
        DescType typeCode;
 
270
        Size dataSize;
 
271
#ifndef AESizeOfNthItem
 
272
        PyMac_PRECHECK(AESizeOfNthItem);
 
273
#endif
 
274
        if (!PyArg_ParseTuple(_args, "l",
 
275
                              &index))
 
276
                return NULL;
 
277
        _err = AESizeOfNthItem(&_self->ob_itself,
 
278
                               index,
 
279
                               &typeCode,
 
280
                               &dataSize);
 
281
        if (_err != noErr) return PyMac_Error(_err);
 
282
        _res = Py_BuildValue("O&l",
 
283
                             PyMac_BuildOSType, typeCode,
 
284
                             dataSize);
 
285
        return _res;
 
286
}
 
287
 
 
288
static PyObject *AEDesc_AEDeleteItem(AEDescObject *_self, PyObject *_args)
 
289
{
 
290
        PyObject *_res = NULL;
 
291
        OSErr _err;
 
292
        long index;
 
293
#ifndef AEDeleteItem
 
294
        PyMac_PRECHECK(AEDeleteItem);
 
295
#endif
 
296
        if (!PyArg_ParseTuple(_args, "l",
 
297
                              &index))
 
298
                return NULL;
 
299
        _err = AEDeleteItem(&_self->ob_itself,
 
300
                            index);
 
301
        if (_err != noErr) return PyMac_Error(_err);
 
302
        Py_INCREF(Py_None);
 
303
        _res = Py_None;
 
304
        return _res;
 
305
}
 
306
 
 
307
static PyObject *AEDesc_AEPutParamPtr(AEDescObject *_self, PyObject *_args)
 
308
{
 
309
        PyObject *_res = NULL;
 
310
        OSErr _err;
 
311
        AEKeyword theAEKeyword;
 
312
        DescType typeCode;
 
313
        char *dataPtr__in__;
 
314
        long dataPtr__len__;
 
315
        int dataPtr__in_len__;
 
316
#ifndef AEPutParamPtr
 
317
        PyMac_PRECHECK(AEPutParamPtr);
 
318
#endif
 
319
        if (!PyArg_ParseTuple(_args, "O&O&s#",
 
320
                              PyMac_GetOSType, &theAEKeyword,
 
321
                              PyMac_GetOSType, &typeCode,
 
322
                              &dataPtr__in__, &dataPtr__in_len__))
 
323
                return NULL;
 
324
        dataPtr__len__ = dataPtr__in_len__;
 
325
        _err = AEPutParamPtr(&_self->ob_itself,
 
326
                             theAEKeyword,
 
327
                             typeCode,
 
328
                             dataPtr__in__, dataPtr__len__);
 
329
        if (_err != noErr) return PyMac_Error(_err);
 
330
        Py_INCREF(Py_None);
 
331
        _res = Py_None;
 
332
        return _res;
 
333
}
 
334
 
 
335
static PyObject *AEDesc_AEPutParamDesc(AEDescObject *_self, PyObject *_args)
 
336
{
 
337
        PyObject *_res = NULL;
 
338
        OSErr _err;
 
339
        AEKeyword theAEKeyword;
 
340
        AEDesc theAEDesc;
 
341
#ifndef AEPutParamDesc
 
342
        PyMac_PRECHECK(AEPutParamDesc);
 
343
#endif
 
344
        if (!PyArg_ParseTuple(_args, "O&O&",
 
345
                              PyMac_GetOSType, &theAEKeyword,
 
346
                              AEDesc_Convert, &theAEDesc))
 
347
                return NULL;
 
348
        _err = AEPutParamDesc(&_self->ob_itself,
 
349
                              theAEKeyword,
 
350
                              &theAEDesc);
 
351
        if (_err != noErr) return PyMac_Error(_err);
 
352
        Py_INCREF(Py_None);
 
353
        _res = Py_None;
 
354
        return _res;
 
355
}
 
356
 
 
357
static PyObject *AEDesc_AEGetParamPtr(AEDescObject *_self, PyObject *_args)
 
358
{
 
359
        PyObject *_res = NULL;
 
360
        OSErr _err;
 
361
        AEKeyword theAEKeyword;
 
362
        DescType desiredType;
 
363
        DescType typeCode;
 
364
        char *dataPtr__out__;
 
365
        long dataPtr__len__;
 
366
        int dataPtr__in_len__;
 
367
#ifndef AEGetParamPtr
 
368
        PyMac_PRECHECK(AEGetParamPtr);
 
369
#endif
 
370
        if (!PyArg_ParseTuple(_args, "O&O&i",
 
371
                              PyMac_GetOSType, &theAEKeyword,
 
372
                              PyMac_GetOSType, &desiredType,
 
373
                              &dataPtr__in_len__))
 
374
                return NULL;
 
375
        if ((dataPtr__out__ = malloc(dataPtr__in_len__)) == NULL)
 
376
        {
 
377
                PyErr_NoMemory();
 
378
                goto dataPtr__error__;
 
379
        }
 
380
        dataPtr__len__ = dataPtr__in_len__;
 
381
        _err = AEGetParamPtr(&_self->ob_itself,
 
382
                             theAEKeyword,
 
383
                             desiredType,
 
384
                             &typeCode,
 
385
                             dataPtr__out__, dataPtr__len__, &dataPtr__len__);
 
386
        if (_err != noErr) return PyMac_Error(_err);
 
387
        _res = Py_BuildValue("O&s#",
 
388
                             PyMac_BuildOSType, typeCode,
 
389
                             dataPtr__out__, (int)dataPtr__len__);
 
390
        free(dataPtr__out__);
 
391
 dataPtr__error__: ;
 
392
        return _res;
 
393
}
 
394
 
 
395
static PyObject *AEDesc_AEGetParamDesc(AEDescObject *_self, PyObject *_args)
 
396
{
 
397
        PyObject *_res = NULL;
 
398
        OSErr _err;
 
399
        AEKeyword theAEKeyword;
 
400
        DescType desiredType;
 
401
        AEDesc result;
 
402
#ifndef AEGetParamDesc
 
403
        PyMac_PRECHECK(AEGetParamDesc);
 
404
#endif
 
405
        if (!PyArg_ParseTuple(_args, "O&O&",
 
406
                              PyMac_GetOSType, &theAEKeyword,
 
407
                              PyMac_GetOSType, &desiredType))
 
408
                return NULL;
 
409
        _err = AEGetParamDesc(&_self->ob_itself,
 
410
                              theAEKeyword,
 
411
                              desiredType,
 
412
                              &result);
 
413
        if (_err != noErr) return PyMac_Error(_err);
 
414
        _res = Py_BuildValue("O&",
 
415
                             AEDesc_New, &result);
 
416
        return _res;
 
417
}
 
418
 
 
419
static PyObject *AEDesc_AESizeOfParam(AEDescObject *_self, PyObject *_args)
 
420
{
 
421
        PyObject *_res = NULL;
 
422
        OSErr _err;
 
423
        AEKeyword theAEKeyword;
 
424
        DescType typeCode;
 
425
        Size dataSize;
 
426
#ifndef AESizeOfParam
 
427
        PyMac_PRECHECK(AESizeOfParam);
 
428
#endif
 
429
        if (!PyArg_ParseTuple(_args, "O&",
 
430
                              PyMac_GetOSType, &theAEKeyword))
 
431
                return NULL;
 
432
        _err = AESizeOfParam(&_self->ob_itself,
 
433
                             theAEKeyword,
 
434
                             &typeCode,
 
435
                             &dataSize);
 
436
        if (_err != noErr) return PyMac_Error(_err);
 
437
        _res = Py_BuildValue("O&l",
 
438
                             PyMac_BuildOSType, typeCode,
 
439
                             dataSize);
 
440
        return _res;
 
441
}
 
442
 
 
443
static PyObject *AEDesc_AEDeleteParam(AEDescObject *_self, PyObject *_args)
 
444
{
 
445
        PyObject *_res = NULL;
 
446
        OSErr _err;
 
447
        AEKeyword theAEKeyword;
 
448
#ifndef AEDeleteParam
 
449
        PyMac_PRECHECK(AEDeleteParam);
 
450
#endif
 
451
        if (!PyArg_ParseTuple(_args, "O&",
 
452
                              PyMac_GetOSType, &theAEKeyword))
 
453
                return NULL;
 
454
        _err = AEDeleteParam(&_self->ob_itself,
 
455
                             theAEKeyword);
 
456
        if (_err != noErr) return PyMac_Error(_err);
 
457
        Py_INCREF(Py_None);
 
458
        _res = Py_None;
 
459
        return _res;
 
460
}
 
461
 
 
462
static PyObject *AEDesc_AEGetAttributePtr(AEDescObject *_self, PyObject *_args)
 
463
{
 
464
        PyObject *_res = NULL;
 
465
        OSErr _err;
 
466
        AEKeyword theAEKeyword;
 
467
        DescType desiredType;
 
468
        DescType typeCode;
 
469
        char *dataPtr__out__;
 
470
        long dataPtr__len__;
 
471
        int dataPtr__in_len__;
 
472
#ifndef AEGetAttributePtr
 
473
        PyMac_PRECHECK(AEGetAttributePtr);
 
474
#endif
 
475
        if (!PyArg_ParseTuple(_args, "O&O&i",
 
476
                              PyMac_GetOSType, &theAEKeyword,
 
477
                              PyMac_GetOSType, &desiredType,
 
478
                              &dataPtr__in_len__))
 
479
                return NULL;
 
480
        if ((dataPtr__out__ = malloc(dataPtr__in_len__)) == NULL)
 
481
        {
 
482
                PyErr_NoMemory();
 
483
                goto dataPtr__error__;
 
484
        }
 
485
        dataPtr__len__ = dataPtr__in_len__;
 
486
        _err = AEGetAttributePtr(&_self->ob_itself,
 
487
                                 theAEKeyword,
 
488
                                 desiredType,
 
489
                                 &typeCode,
 
490
                                 dataPtr__out__, dataPtr__len__, &dataPtr__len__);
 
491
        if (_err != noErr) return PyMac_Error(_err);
 
492
        _res = Py_BuildValue("O&s#",
 
493
                             PyMac_BuildOSType, typeCode,
 
494
                             dataPtr__out__, (int)dataPtr__len__);
 
495
        free(dataPtr__out__);
 
496
 dataPtr__error__: ;
 
497
        return _res;
 
498
}
 
499
 
 
500
static PyObject *AEDesc_AEGetAttributeDesc(AEDescObject *_self, PyObject *_args)
 
501
{
 
502
        PyObject *_res = NULL;
 
503
        OSErr _err;
 
504
        AEKeyword theAEKeyword;
 
505
        DescType desiredType;
 
506
        AEDesc result;
 
507
#ifndef AEGetAttributeDesc
 
508
        PyMac_PRECHECK(AEGetAttributeDesc);
 
509
#endif
 
510
        if (!PyArg_ParseTuple(_args, "O&O&",
 
511
                              PyMac_GetOSType, &theAEKeyword,
 
512
                              PyMac_GetOSType, &desiredType))
 
513
                return NULL;
 
514
        _err = AEGetAttributeDesc(&_self->ob_itself,
 
515
                                  theAEKeyword,
 
516
                                  desiredType,
 
517
                                  &result);
 
518
        if (_err != noErr) return PyMac_Error(_err);
 
519
        _res = Py_BuildValue("O&",
 
520
                             AEDesc_New, &result);
 
521
        return _res;
 
522
}
 
523
 
 
524
static PyObject *AEDesc_AESizeOfAttribute(AEDescObject *_self, PyObject *_args)
 
525
{
 
526
        PyObject *_res = NULL;
 
527
        OSErr _err;
 
528
        AEKeyword theAEKeyword;
 
529
        DescType typeCode;
 
530
        Size dataSize;
 
531
#ifndef AESizeOfAttribute
 
532
        PyMac_PRECHECK(AESizeOfAttribute);
 
533
#endif
 
534
        if (!PyArg_ParseTuple(_args, "O&",
 
535
                              PyMac_GetOSType, &theAEKeyword))
 
536
                return NULL;
 
537
        _err = AESizeOfAttribute(&_self->ob_itself,
 
538
                                 theAEKeyword,
 
539
                                 &typeCode,
 
540
                                 &dataSize);
 
541
        if (_err != noErr) return PyMac_Error(_err);
 
542
        _res = Py_BuildValue("O&l",
 
543
                             PyMac_BuildOSType, typeCode,
 
544
                             dataSize);
 
545
        return _res;
 
546
}
 
547
 
 
548
static PyObject *AEDesc_AEPutAttributePtr(AEDescObject *_self, PyObject *_args)
 
549
{
 
550
        PyObject *_res = NULL;
 
551
        OSErr _err;
 
552
        AEKeyword theAEKeyword;
 
553
        DescType typeCode;
 
554
        char *dataPtr__in__;
 
555
        long dataPtr__len__;
 
556
        int dataPtr__in_len__;
 
557
#ifndef AEPutAttributePtr
 
558
        PyMac_PRECHECK(AEPutAttributePtr);
 
559
#endif
 
560
        if (!PyArg_ParseTuple(_args, "O&O&s#",
 
561
                              PyMac_GetOSType, &theAEKeyword,
 
562
                              PyMac_GetOSType, &typeCode,
 
563
                              &dataPtr__in__, &dataPtr__in_len__))
 
564
                return NULL;
 
565
        dataPtr__len__ = dataPtr__in_len__;
 
566
        _err = AEPutAttributePtr(&_self->ob_itself,
 
567
                                 theAEKeyword,
 
568
                                 typeCode,
 
569
                                 dataPtr__in__, dataPtr__len__);
 
570
        if (_err != noErr) return PyMac_Error(_err);
 
571
        Py_INCREF(Py_None);
 
572
        _res = Py_None;
 
573
        return _res;
 
574
}
 
575
 
 
576
static PyObject *AEDesc_AEPutAttributeDesc(AEDescObject *_self, PyObject *_args)
 
577
{
 
578
        PyObject *_res = NULL;
 
579
        OSErr _err;
 
580
        AEKeyword theAEKeyword;
 
581
        AEDesc theAEDesc;
 
582
#ifndef AEPutAttributeDesc
 
583
        PyMac_PRECHECK(AEPutAttributeDesc);
 
584
#endif
 
585
        if (!PyArg_ParseTuple(_args, "O&O&",
 
586
                              PyMac_GetOSType, &theAEKeyword,
 
587
                              AEDesc_Convert, &theAEDesc))
 
588
                return NULL;
 
589
        _err = AEPutAttributeDesc(&_self->ob_itself,
 
590
                                  theAEKeyword,
 
591
                                  &theAEDesc);
 
592
        if (_err != noErr) return PyMac_Error(_err);
 
593
        Py_INCREF(Py_None);
 
594
        _res = Py_None;
 
595
        return _res;
 
596
}
 
597
 
 
598
static PyObject *AEDesc_AEGetDescDataSize(AEDescObject *_self, PyObject *_args)
 
599
{
 
600
        PyObject *_res = NULL;
 
601
        Size _rv;
 
602
#ifndef AEGetDescDataSize
 
603
        PyMac_PRECHECK(AEGetDescDataSize);
 
604
#endif
 
605
        if (!PyArg_ParseTuple(_args, ""))
 
606
                return NULL;
 
607
        _rv = AEGetDescDataSize(&_self->ob_itself);
 
608
        _res = Py_BuildValue("l",
 
609
                             _rv);
 
610
        return _res;
 
611
}
 
612
 
 
613
static PyObject *AEDesc_AESend(AEDescObject *_self, PyObject *_args)
 
614
{
 
615
        PyObject *_res = NULL;
 
616
        OSErr _err;
 
617
        AppleEvent reply;
 
618
        AESendMode sendMode;
 
619
        AESendPriority sendPriority;
 
620
        long timeOutInTicks;
 
621
#ifndef AESend
 
622
        PyMac_PRECHECK(AESend);
 
623
#endif
 
624
        if (!PyArg_ParseTuple(_args, "lhl",
 
625
                              &sendMode,
 
626
                              &sendPriority,
 
627
                              &timeOutInTicks))
 
628
                return NULL;
 
629
        _err = AESend(&_self->ob_itself,
 
630
                      &reply,
 
631
                      sendMode,
 
632
                      sendPriority,
 
633
                      timeOutInTicks,
 
634
                      upp_AEIdleProc,
 
635
                      (AEFilterUPP)0);
 
636
        if (_err != noErr) return PyMac_Error(_err);
 
637
        _res = Py_BuildValue("O&",
 
638
                             AEDesc_New, &reply);
 
639
        return _res;
 
640
}
 
641
 
 
642
static PyObject *AEDesc_AEResetTimer(AEDescObject *_self, PyObject *_args)
 
643
{
 
644
        PyObject *_res = NULL;
 
645
        OSErr _err;
 
646
#ifndef AEResetTimer
 
647
        PyMac_PRECHECK(AEResetTimer);
 
648
#endif
 
649
        if (!PyArg_ParseTuple(_args, ""))
 
650
                return NULL;
 
651
        _err = AEResetTimer(&_self->ob_itself);
 
652
        if (_err != noErr) return PyMac_Error(_err);
 
653
        Py_INCREF(Py_None);
 
654
        _res = Py_None;
 
655
        return _res;
 
656
}
 
657
 
 
658
static PyObject *AEDesc_AESuspendTheCurrentEvent(AEDescObject *_self, PyObject *_args)
 
659
{
 
660
        PyObject *_res = NULL;
 
661
        OSErr _err;
 
662
#ifndef AESuspendTheCurrentEvent
 
663
        PyMac_PRECHECK(AESuspendTheCurrentEvent);
 
664
#endif
 
665
        if (!PyArg_ParseTuple(_args, ""))
 
666
                return NULL;
 
667
        _err = AESuspendTheCurrentEvent(&_self->ob_itself);
 
668
        if (_err != noErr) return PyMac_Error(_err);
 
669
        Py_INCREF(Py_None);
 
670
        _res = Py_None;
 
671
        return _res;
 
672
}
 
673
 
 
674
static PyObject *AEDesc_AEResumeTheCurrentEvent(AEDescObject *_self, PyObject *_args)
 
675
{
 
676
        PyObject *_res = NULL;
 
677
        OSErr _err;
 
678
        AppleEvent reply;
 
679
        AEEventHandlerUPP dispatcher__proc__ = upp_GenericEventHandler;
 
680
        PyObject *dispatcher;
 
681
#ifndef AEResumeTheCurrentEvent
 
682
        PyMac_PRECHECK(AEResumeTheCurrentEvent);
 
683
#endif
 
684
        if (!PyArg_ParseTuple(_args, "O&O",
 
685
                              AEDesc_Convert, &reply,
 
686
                              &dispatcher))
 
687
                return NULL;
 
688
        _err = AEResumeTheCurrentEvent(&_self->ob_itself,
 
689
                                       &reply,
 
690
                                       dispatcher__proc__, 
 
691
                                       (SRefCon)dispatcher);
 
692
        if (_err != noErr) return PyMac_Error(_err);
 
693
        Py_INCREF(Py_None);
 
694
        _res = Py_None;
 
695
        Py_INCREF(dispatcher); /* XXX leak, but needed */
 
696
        return _res;
 
697
}
 
698
 
 
699
static PyObject *AEDesc_AEGetTheCurrentEvent(AEDescObject *_self, PyObject *_args)
 
700
{
 
701
        PyObject *_res = NULL;
 
702
        OSErr _err;
 
703
#ifndef AEGetTheCurrentEvent
 
704
        PyMac_PRECHECK(AEGetTheCurrentEvent);
 
705
#endif
 
706
        if (!PyArg_ParseTuple(_args, ""))
 
707
                return NULL;
 
708
        _err = AEGetTheCurrentEvent(&_self->ob_itself);
 
709
        if (_err != noErr) return PyMac_Error(_err);
 
710
        Py_INCREF(Py_None);
 
711
        _res = Py_None;
 
712
        return _res;
 
713
}
 
714
 
 
715
static PyObject *AEDesc_AESetTheCurrentEvent(AEDescObject *_self, PyObject *_args)
 
716
{
 
717
        PyObject *_res = NULL;
 
718
        OSErr _err;
 
719
#ifndef AESetTheCurrentEvent
 
720
        PyMac_PRECHECK(AESetTheCurrentEvent);
 
721
#endif
 
722
        if (!PyArg_ParseTuple(_args, ""))
 
723
                return NULL;
 
724
        _err = AESetTheCurrentEvent(&_self->ob_itself);
 
725
        if (_err != noErr) return PyMac_Error(_err);
 
726
        Py_INCREF(Py_None);
 
727
        _res = Py_None;
 
728
        return _res;
 
729
}
 
730
 
 
731
static PyObject *AEDesc_AEResolve(AEDescObject *_self, PyObject *_args)
 
732
{
 
733
        PyObject *_res = NULL;
 
734
        OSErr _err;
 
735
        short callbackFlags;
 
736
        AEDesc theToken;
 
737
#ifndef AEResolve
 
738
        PyMac_PRECHECK(AEResolve);
 
739
#endif
 
740
        if (!PyArg_ParseTuple(_args, "h",
 
741
                              &callbackFlags))
 
742
                return NULL;
 
743
        _err = AEResolve(&_self->ob_itself,
 
744
                         callbackFlags,
 
745
                         &theToken);
 
746
        if (_err != noErr) return PyMac_Error(_err);
 
747
        _res = Py_BuildValue("O&",
 
748
                             AEDesc_New, &theToken);
 
749
        return _res;
 
750
}
 
751
 
 
752
static PyObject *AEDesc_AutoDispose(AEDescObject *_self, PyObject *_args)
 
753
{
 
754
        PyObject *_res = NULL;
 
755
 
 
756
        int onoff, old;
 
757
        if (!PyArg_ParseTuple(_args, "i", &onoff))
 
758
                return NULL;
 
759
        old = _self->ob_owned;
 
760
        _self->ob_owned = onoff;
 
761
        _res = Py_BuildValue("i", old);
 
762
        return _res;
 
763
 
 
764
}
 
765
 
 
766
static PyMethodDef AEDesc_methods[] = {
 
767
        {"AECoerceDesc", (PyCFunction)AEDesc_AECoerceDesc, 1,
 
768
         PyDoc_STR("(DescType toType) -> (AEDesc result)")},
 
769
        {"AEDuplicateDesc", (PyCFunction)AEDesc_AEDuplicateDesc, 1,
 
770
         PyDoc_STR("() -> (AEDesc result)")},
 
771
        {"AECountItems", (PyCFunction)AEDesc_AECountItems, 1,
 
772
         PyDoc_STR("() -> (long theCount)")},
 
773
        {"AEPutPtr", (PyCFunction)AEDesc_AEPutPtr, 1,
 
774
         PyDoc_STR("(long index, DescType typeCode, Buffer dataPtr) -> None")},
 
775
        {"AEPutDesc", (PyCFunction)AEDesc_AEPutDesc, 1,
 
776
         PyDoc_STR("(long index, AEDesc theAEDesc) -> None")},
 
777
        {"AEGetNthPtr", (PyCFunction)AEDesc_AEGetNthPtr, 1,
 
778
         PyDoc_STR("(long index, DescType desiredType, Buffer dataPtr) -> (AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr)")},
 
779
        {"AEGetNthDesc", (PyCFunction)AEDesc_AEGetNthDesc, 1,
 
780
         PyDoc_STR("(long index, DescType desiredType) -> (AEKeyword theAEKeyword, AEDesc result)")},
 
781
        {"AESizeOfNthItem", (PyCFunction)AEDesc_AESizeOfNthItem, 1,
 
782
         PyDoc_STR("(long index) -> (DescType typeCode, Size dataSize)")},
 
783
        {"AEDeleteItem", (PyCFunction)AEDesc_AEDeleteItem, 1,
 
784
         PyDoc_STR("(long index) -> None")},
 
785
        {"AEPutParamPtr", (PyCFunction)AEDesc_AEPutParamPtr, 1,
 
786
         PyDoc_STR("(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None")},
 
787
        {"AEPutParamDesc", (PyCFunction)AEDesc_AEPutParamDesc, 1,
 
788
         PyDoc_STR("(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None")},
 
789
        {"AEGetParamPtr", (PyCFunction)AEDesc_AEGetParamPtr, 1,
 
790
         PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)")},
 
791
        {"AEGetParamDesc", (PyCFunction)AEDesc_AEGetParamDesc, 1,
 
792
         PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)")},
 
793
        {"AESizeOfParam", (PyCFunction)AEDesc_AESizeOfParam, 1,
 
794
         PyDoc_STR("(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)")},
 
795
        {"AEDeleteParam", (PyCFunction)AEDesc_AEDeleteParam, 1,
 
796
         PyDoc_STR("(AEKeyword theAEKeyword) -> None")},
 
797
        {"AEGetAttributePtr", (PyCFunction)AEDesc_AEGetAttributePtr, 1,
 
798
         PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)")},
 
799
        {"AEGetAttributeDesc", (PyCFunction)AEDesc_AEGetAttributeDesc, 1,
 
800
         PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)")},
 
801
        {"AESizeOfAttribute", (PyCFunction)AEDesc_AESizeOfAttribute, 1,
 
802
         PyDoc_STR("(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)")},
 
803
        {"AEPutAttributePtr", (PyCFunction)AEDesc_AEPutAttributePtr, 1,
 
804
         PyDoc_STR("(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None")},
 
805
        {"AEPutAttributeDesc", (PyCFunction)AEDesc_AEPutAttributeDesc, 1,
 
806
         PyDoc_STR("(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None")},
 
807
        {"AEGetDescDataSize", (PyCFunction)AEDesc_AEGetDescDataSize, 1,
 
808
         PyDoc_STR("() -> (Size _rv)")},
 
809
        {"AESend", (PyCFunction)AEDesc_AESend, 1,
 
810
         PyDoc_STR("(AESendMode sendMode, AESendPriority sendPriority, long timeOutInTicks) -> (AppleEvent reply)")},
 
811
        {"AEResetTimer", (PyCFunction)AEDesc_AEResetTimer, 1,
 
812
         PyDoc_STR("() -> None")},
 
813
        {"AESuspendTheCurrentEvent", (PyCFunction)AEDesc_AESuspendTheCurrentEvent, 1,
 
814
         PyDoc_STR("() -> None")},
 
815
        {"AEResumeTheCurrentEvent", (PyCFunction)AEDesc_AEResumeTheCurrentEvent, 1,
 
816
         PyDoc_STR("(AppleEvent reply, EventHandler dispatcher) -> None")},
 
817
        {"AEGetTheCurrentEvent", (PyCFunction)AEDesc_AEGetTheCurrentEvent, 1,
 
818
         PyDoc_STR("() -> None")},
 
819
        {"AESetTheCurrentEvent", (PyCFunction)AEDesc_AESetTheCurrentEvent, 1,
 
820
         PyDoc_STR("() -> None")},
 
821
        {"AEResolve", (PyCFunction)AEDesc_AEResolve, 1,
 
822
         PyDoc_STR("(short callbackFlags) -> (AEDesc theToken)")},
 
823
        {"AutoDispose", (PyCFunction)AEDesc_AutoDispose, 1,
 
824
         PyDoc_STR("(int)->int. Automatically AEDisposeDesc the object on Python object cleanup")},
 
825
        {NULL, NULL, 0}
 
826
};
 
827
 
 
828
static PyObject *AEDesc_get_type(AEDescObject *self, void *closure)
 
829
{
 
830
        return PyMac_BuildOSType(self->ob_itself.descriptorType);
 
831
}
 
832
 
 
833
#define AEDesc_set_type NULL
 
834
 
 
835
static PyObject *AEDesc_get_data(AEDescObject *self, void *closure)
 
836
{
 
837
        PyObject *res;
 
838
        Size size;
 
839
        char *ptr;
 
840
        OSErr err;
 
841
 
 
842
        size = AEGetDescDataSize(&self->ob_itself);
 
843
        if ( (res = PyString_FromStringAndSize(NULL, size)) == NULL )
 
844
                return NULL;
 
845
        if ( (ptr = PyString_AsString(res)) == NULL )
 
846
                return NULL;
 
847
        if ( (err=AEGetDescData(&self->ob_itself, ptr, size)) < 0 )
 
848
                return PyMac_Error(err);
 
849
        return res;
 
850
}
 
851
 
 
852
#define AEDesc_set_data NULL
 
853
 
 
854
static PyGetSetDef AEDesc_getsetlist[] = {
 
855
        {"type", (getter)AEDesc_get_type, (setter)AEDesc_set_type, "Type of this AEDesc"},
 
856
        {"data", (getter)AEDesc_get_data, (setter)AEDesc_set_data, "The raw data in this AEDesc"},
 
857
        {NULL, NULL, NULL, NULL},
 
858
};
 
859
 
 
860
 
 
861
#define AEDesc_compare NULL
 
862
 
 
863
#define AEDesc_repr NULL
 
864
 
 
865
#define AEDesc_hash NULL
 
866
#define AEDesc_tp_init 0
 
867
 
 
868
#define AEDesc_tp_alloc PyType_GenericAlloc
 
869
 
 
870
static PyObject *AEDesc_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
 
871
{
 
872
        PyObject *_self;
 
873
        AEDesc itself;
 
874
        char *kw[] = {"itself", 0};
 
875
 
 
876
        if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, AEDesc_Convert, &itself)) return NULL;
 
877
        if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
 
878
        ((AEDescObject *)_self)->ob_itself = itself;
 
879
        return _self;
 
880
}
 
881
 
 
882
#define AEDesc_tp_free PyObject_Del
 
883
 
 
884
 
 
885
PyTypeObject AEDesc_Type = {
 
886
        PyObject_HEAD_INIT(NULL)
 
887
        0, /*ob_size*/
 
888
        "_AE.AEDesc", /*tp_name*/
 
889
        sizeof(AEDescObject), /*tp_basicsize*/
 
890
        0, /*tp_itemsize*/
 
891
        /* methods */
 
892
        (destructor) AEDesc_dealloc, /*tp_dealloc*/
 
893
        0, /*tp_print*/
 
894
        (getattrfunc)0, /*tp_getattr*/
 
895
        (setattrfunc)0, /*tp_setattr*/
 
896
        (cmpfunc) AEDesc_compare, /*tp_compare*/
 
897
        (reprfunc) AEDesc_repr, /*tp_repr*/
 
898
        (PyNumberMethods *)0, /* tp_as_number */
 
899
        (PySequenceMethods *)0, /* tp_as_sequence */
 
900
        (PyMappingMethods *)0, /* tp_as_mapping */
 
901
        (hashfunc) AEDesc_hash, /*tp_hash*/
 
902
        0, /*tp_call*/
 
903
        0, /*tp_str*/
 
904
        PyObject_GenericGetAttr, /*tp_getattro*/
 
905
        PyObject_GenericSetAttr, /*tp_setattro */
 
906
        0, /*tp_as_buffer*/
 
907
        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
 
908
        0, /*tp_doc*/
 
909
        0, /*tp_traverse*/
 
910
        0, /*tp_clear*/
 
911
        0, /*tp_richcompare*/
 
912
        0, /*tp_weaklistoffset*/
 
913
        0, /*tp_iter*/
 
914
        0, /*tp_iternext*/
 
915
        AEDesc_methods, /* tp_methods */
 
916
        0, /*tp_members*/
 
917
        AEDesc_getsetlist, /*tp_getset*/
 
918
        0, /*tp_base*/
 
919
        0, /*tp_dict*/
 
920
        0, /*tp_descr_get*/
 
921
        0, /*tp_descr_set*/
 
922
        0, /*tp_dictoffset*/
 
923
        AEDesc_tp_init, /* tp_init */
 
924
        AEDesc_tp_alloc, /* tp_alloc */
 
925
        AEDesc_tp_new, /* tp_new */
 
926
        AEDesc_tp_free, /* tp_free */
 
927
};
 
928
 
 
929
/* --------------------- End object type AEDesc --------------------- */
 
930
 
 
931
 
 
932
static PyObject *AE_AECoercePtr(PyObject *_self, PyObject *_args)
 
933
{
 
934
        PyObject *_res = NULL;
 
935
        OSErr _err;
 
936
        DescType typeCode;
 
937
        char *dataPtr__in__;
 
938
        long dataPtr__len__;
 
939
        int dataPtr__in_len__;
 
940
        DescType toType;
 
941
        AEDesc result;
 
942
#ifndef AECoercePtr
 
943
        PyMac_PRECHECK(AECoercePtr);
 
944
#endif
 
945
        if (!PyArg_ParseTuple(_args, "O&s#O&",
 
946
                              PyMac_GetOSType, &typeCode,
 
947
                              &dataPtr__in__, &dataPtr__in_len__,
 
948
                              PyMac_GetOSType, &toType))
 
949
                return NULL;
 
950
        dataPtr__len__ = dataPtr__in_len__;
 
951
        _err = AECoercePtr(typeCode,
 
952
                           dataPtr__in__, dataPtr__len__,
 
953
                           toType,
 
954
                           &result);
 
955
        if (_err != noErr) return PyMac_Error(_err);
 
956
        _res = Py_BuildValue("O&",
 
957
                             AEDesc_New, &result);
 
958
        return _res;
 
959
}
 
960
 
 
961
static PyObject *AE_AECreateDesc(PyObject *_self, PyObject *_args)
 
962
{
 
963
        PyObject *_res = NULL;
 
964
        OSErr _err;
 
965
        DescType typeCode;
 
966
        char *dataPtr__in__;
 
967
        long dataPtr__len__;
 
968
        int dataPtr__in_len__;
 
969
        AEDesc result;
 
970
#ifndef AECreateDesc
 
971
        PyMac_PRECHECK(AECreateDesc);
 
972
#endif
 
973
        if (!PyArg_ParseTuple(_args, "O&s#",
 
974
                              PyMac_GetOSType, &typeCode,
 
975
                              &dataPtr__in__, &dataPtr__in_len__))
 
976
                return NULL;
 
977
        dataPtr__len__ = dataPtr__in_len__;
 
978
        _err = AECreateDesc(typeCode,
 
979
                            dataPtr__in__, dataPtr__len__,
 
980
                            &result);
 
981
        if (_err != noErr) return PyMac_Error(_err);
 
982
        _res = Py_BuildValue("O&",
 
983
                             AEDesc_New, &result);
 
984
        return _res;
 
985
}
 
986
 
 
987
static PyObject *AE_AECreateList(PyObject *_self, PyObject *_args)
 
988
{
 
989
        PyObject *_res = NULL;
 
990
        OSErr _err;
 
991
        char *factoringPtr__in__;
 
992
        long factoringPtr__len__;
 
993
        int factoringPtr__in_len__;
 
994
        Boolean isRecord;
 
995
        AEDescList resultList;
 
996
#ifndef AECreateList
 
997
        PyMac_PRECHECK(AECreateList);
 
998
#endif
 
999
        if (!PyArg_ParseTuple(_args, "s#b",
 
1000
                              &factoringPtr__in__, &factoringPtr__in_len__,
 
1001
                              &isRecord))
 
1002
                return NULL;
 
1003
        factoringPtr__len__ = factoringPtr__in_len__;
 
1004
        _err = AECreateList(factoringPtr__in__, factoringPtr__len__,
 
1005
                            isRecord,
 
1006
                            &resultList);
 
1007
        if (_err != noErr) return PyMac_Error(_err);
 
1008
        _res = Py_BuildValue("O&",
 
1009
                             AEDesc_New, &resultList);
 
1010
        return _res;
 
1011
}
 
1012
 
 
1013
static PyObject *AE_AECreateAppleEvent(PyObject *_self, PyObject *_args)
 
1014
{
 
1015
        PyObject *_res = NULL;
 
1016
        OSErr _err;
 
1017
        AEEventClass theAEEventClass;
 
1018
        AEEventID theAEEventID;
 
1019
        AEAddressDesc target;
 
1020
        AEReturnID returnID;
 
1021
        AETransactionID transactionID;
 
1022
        AppleEvent result;
 
1023
#ifndef AECreateAppleEvent
 
1024
        PyMac_PRECHECK(AECreateAppleEvent);
 
1025
#endif
 
1026
        if (!PyArg_ParseTuple(_args, "O&O&O&hl",
 
1027
                              PyMac_GetOSType, &theAEEventClass,
 
1028
                              PyMac_GetOSType, &theAEEventID,
 
1029
                              AEDesc_Convert, &target,
 
1030
                              &returnID,
 
1031
                              &transactionID))
 
1032
                return NULL;
 
1033
        _err = AECreateAppleEvent(theAEEventClass,
 
1034
                                  theAEEventID,
 
1035
                                  &target,
 
1036
                                  returnID,
 
1037
                                  transactionID,
 
1038
                                  &result);
 
1039
        if (_err != noErr) return PyMac_Error(_err);
 
1040
        _res = Py_BuildValue("O&",
 
1041
                             AEDesc_New, &result);
 
1042
        return _res;
 
1043
}
 
1044
 
 
1045
static PyObject *AE_AEReplaceDescData(PyObject *_self, PyObject *_args)
 
1046
{
 
1047
        PyObject *_res = NULL;
 
1048
        OSErr _err;
 
1049
        DescType typeCode;
 
1050
        char *dataPtr__in__;
 
1051
        long dataPtr__len__;
 
1052
        int dataPtr__in_len__;
 
1053
        AEDesc theAEDesc;
 
1054
#ifndef AEReplaceDescData
 
1055
        PyMac_PRECHECK(AEReplaceDescData);
 
1056
#endif
 
1057
        if (!PyArg_ParseTuple(_args, "O&s#",
 
1058
                              PyMac_GetOSType, &typeCode,
 
1059
                              &dataPtr__in__, &dataPtr__in_len__))
 
1060
                return NULL;
 
1061
        dataPtr__len__ = dataPtr__in_len__;
 
1062
        _err = AEReplaceDescData(typeCode,
 
1063
                                 dataPtr__in__, dataPtr__len__,
 
1064
                                 &theAEDesc);
 
1065
        if (_err != noErr) return PyMac_Error(_err);
 
1066
        _res = Py_BuildValue("O&",
 
1067
                             AEDesc_New, &theAEDesc);
 
1068
        return _res;
 
1069
}
 
1070
 
 
1071
static PyObject *AE_AEProcessAppleEvent(PyObject *_self, PyObject *_args)
 
1072
{
 
1073
        PyObject *_res = NULL;
 
1074
        OSErr _err;
 
1075
        EventRecord theEventRecord;
 
1076
#ifndef AEProcessAppleEvent
 
1077
        PyMac_PRECHECK(AEProcessAppleEvent);
 
1078
#endif
 
1079
        if (!PyArg_ParseTuple(_args, "O&",
 
1080
                              PyMac_GetEventRecord, &theEventRecord))
 
1081
                return NULL;
 
1082
        _err = AEProcessAppleEvent(&theEventRecord);
 
1083
        if (_err != noErr) return PyMac_Error(_err);
 
1084
        Py_INCREF(Py_None);
 
1085
        _res = Py_None;
 
1086
        return _res;
 
1087
}
 
1088
 
 
1089
static PyObject *AE_AEGetInteractionAllowed(PyObject *_self, PyObject *_args)
 
1090
{
 
1091
        PyObject *_res = NULL;
 
1092
        OSErr _err;
 
1093
        AEInteractAllowed level;
 
1094
#ifndef AEGetInteractionAllowed
 
1095
        PyMac_PRECHECK(AEGetInteractionAllowed);
 
1096
#endif
 
1097
        if (!PyArg_ParseTuple(_args, ""))
 
1098
                return NULL;
 
1099
        _err = AEGetInteractionAllowed(&level);
 
1100
        if (_err != noErr) return PyMac_Error(_err);
 
1101
        _res = Py_BuildValue("b",
 
1102
                             level);
 
1103
        return _res;
 
1104
}
 
1105
 
 
1106
static PyObject *AE_AESetInteractionAllowed(PyObject *_self, PyObject *_args)
 
1107
{
 
1108
        PyObject *_res = NULL;
 
1109
        OSErr _err;
 
1110
        AEInteractAllowed level;
 
1111
#ifndef AESetInteractionAllowed
 
1112
        PyMac_PRECHECK(AESetInteractionAllowed);
 
1113
#endif
 
1114
        if (!PyArg_ParseTuple(_args, "b",
 
1115
                              &level))
 
1116
                return NULL;
 
1117
        _err = AESetInteractionAllowed(level);
 
1118
        if (_err != noErr) return PyMac_Error(_err);
 
1119
        Py_INCREF(Py_None);
 
1120
        _res = Py_None;
 
1121
        return _res;
 
1122
}
 
1123
 
 
1124
static PyObject *AE_AEInteractWithUser(PyObject *_self, PyObject *_args)
 
1125
{
 
1126
        PyObject *_res = NULL;
 
1127
        OSErr _err;
 
1128
        long timeOutInTicks;
 
1129
#ifndef AEInteractWithUser
 
1130
        PyMac_PRECHECK(AEInteractWithUser);
 
1131
#endif
 
1132
        if (!PyArg_ParseTuple(_args, "l",
 
1133
                              &timeOutInTicks))
 
1134
                return NULL;
 
1135
        _err = AEInteractWithUser(timeOutInTicks,
 
1136
                                  (NMRecPtr)0,
 
1137
                                  upp_AEIdleProc);
 
1138
        if (_err != noErr) return PyMac_Error(_err);
 
1139
        Py_INCREF(Py_None);
 
1140
        _res = Py_None;
 
1141
        return _res;
 
1142
}
 
1143
 
 
1144
static PyObject *AE_AEInstallEventHandler(PyObject *_self, PyObject *_args)
 
1145
{
 
1146
        PyObject *_res = NULL;
 
1147
        OSErr _err;
 
1148
        AEEventClass theAEEventClass;
 
1149
        AEEventID theAEEventID;
 
1150
        AEEventHandlerUPP handler__proc__ = upp_GenericEventHandler;
 
1151
        PyObject *handler;
 
1152
#ifndef AEInstallEventHandler
 
1153
        PyMac_PRECHECK(AEInstallEventHandler);
 
1154
#endif
 
1155
        if (!PyArg_ParseTuple(_args, "O&O&O",
 
1156
                              PyMac_GetOSType, &theAEEventClass,
 
1157
                              PyMac_GetOSType, &theAEEventID,
 
1158
                              &handler))
 
1159
                return NULL;
 
1160
        _err = AEInstallEventHandler(theAEEventClass,
 
1161
                                     theAEEventID,
 
1162
                                     handler__proc__, (SRefCon)handler,
 
1163
                                     0);
 
1164
        if (_err != noErr) return PyMac_Error(_err);
 
1165
        Py_INCREF(Py_None);
 
1166
        _res = Py_None;
 
1167
        Py_INCREF(handler); /* XXX leak, but needed */
 
1168
        return _res;
 
1169
}
 
1170
 
 
1171
static PyObject *AE_AERemoveEventHandler(PyObject *_self, PyObject *_args)
 
1172
{
 
1173
        PyObject *_res = NULL;
 
1174
        OSErr _err;
 
1175
        AEEventClass theAEEventClass;
 
1176
        AEEventID theAEEventID;
 
1177
#ifndef AERemoveEventHandler
 
1178
        PyMac_PRECHECK(AERemoveEventHandler);
 
1179
#endif
 
1180
        if (!PyArg_ParseTuple(_args, "O&O&",
 
1181
                              PyMac_GetOSType, &theAEEventClass,
 
1182
                              PyMac_GetOSType, &theAEEventID))
 
1183
                return NULL;
 
1184
        _err = AERemoveEventHandler(theAEEventClass,
 
1185
                                    theAEEventID,
 
1186
                                    upp_GenericEventHandler,
 
1187
                                    0);
 
1188
        if (_err != noErr) return PyMac_Error(_err);
 
1189
        Py_INCREF(Py_None);
 
1190
        _res = Py_None;
 
1191
        return _res;
 
1192
}
 
1193
 
 
1194
static PyObject *AE_AEGetEventHandler(PyObject *_self, PyObject *_args)
 
1195
{
 
1196
        PyObject *_res = NULL;
 
1197
        OSErr _err;
 
1198
        AEEventClass theAEEventClass;
 
1199
        AEEventID theAEEventID;
 
1200
        AEEventHandlerUPP handler__proc__ = upp_GenericEventHandler;
 
1201
        PyObject *handler;
 
1202
#ifndef AEGetEventHandler
 
1203
        PyMac_PRECHECK(AEGetEventHandler);
 
1204
#endif
 
1205
        if (!PyArg_ParseTuple(_args, "O&O&",
 
1206
                              PyMac_GetOSType, &theAEEventClass,
 
1207
                              PyMac_GetOSType, &theAEEventID))
 
1208
                return NULL;
 
1209
        _err = AEGetEventHandler(theAEEventClass,
 
1210
                                 theAEEventID,
 
1211
                                 &handler__proc__, (SRefCon *)&handler,
 
1212
                                 0);
 
1213
        if (_err != noErr) return PyMac_Error(_err);
 
1214
        _res = Py_BuildValue("O",
 
1215
                             handler);
 
1216
        Py_INCREF(handler); /* XXX leak, but needed */
 
1217
        return _res;
 
1218
}
 
1219
 
 
1220
static PyObject *AE_AEInstallSpecialHandler(PyObject *_self, PyObject *_args)
 
1221
{
 
1222
        PyObject *_res = NULL;
 
1223
        OSErr _err;
 
1224
        AEKeyword functionClass;
 
1225
#ifndef AEInstallSpecialHandler
 
1226
        PyMac_PRECHECK(AEInstallSpecialHandler);
 
1227
#endif
 
1228
        if (!PyArg_ParseTuple(_args, "O&",
 
1229
                              PyMac_GetOSType, &functionClass))
 
1230
                return NULL;
 
1231
        _err = AEInstallSpecialHandler(functionClass,
 
1232
                                       upp_GenericEventHandler,
 
1233
                                       0);
 
1234
        if (_err != noErr) return PyMac_Error(_err);
 
1235
        Py_INCREF(Py_None);
 
1236
        _res = Py_None;
 
1237
        return _res;
 
1238
}
 
1239
 
 
1240
static PyObject *AE_AERemoveSpecialHandler(PyObject *_self, PyObject *_args)
 
1241
{
 
1242
        PyObject *_res = NULL;
 
1243
        OSErr _err;
 
1244
        AEKeyword functionClass;
 
1245
#ifndef AERemoveSpecialHandler
 
1246
        PyMac_PRECHECK(AERemoveSpecialHandler);
 
1247
#endif
 
1248
        if (!PyArg_ParseTuple(_args, "O&",
 
1249
                              PyMac_GetOSType, &functionClass))
 
1250
                return NULL;
 
1251
        _err = AERemoveSpecialHandler(functionClass,
 
1252
                                      upp_GenericEventHandler,
 
1253
                                      0);
 
1254
        if (_err != noErr) return PyMac_Error(_err);
 
1255
        Py_INCREF(Py_None);
 
1256
        _res = Py_None;
 
1257
        return _res;
 
1258
}
 
1259
 
 
1260
static PyObject *AE_AEManagerInfo(PyObject *_self, PyObject *_args)
 
1261
{
 
1262
        PyObject *_res = NULL;
 
1263
        OSErr _err;
 
1264
        AEKeyword keyWord;
 
1265
        long result;
 
1266
#ifndef AEManagerInfo
 
1267
        PyMac_PRECHECK(AEManagerInfo);
 
1268
#endif
 
1269
        if (!PyArg_ParseTuple(_args, "O&",
 
1270
                              PyMac_GetOSType, &keyWord))
 
1271
                return NULL;
 
1272
        _err = AEManagerInfo(keyWord,
 
1273
                             &result);
 
1274
        if (_err != noErr) return PyMac_Error(_err);
 
1275
        _res = Py_BuildValue("l",
 
1276
                             result);
 
1277
        return _res;
 
1278
}
 
1279
 
 
1280
static PyObject *AE_AEObjectInit(PyObject *_self, PyObject *_args)
 
1281
{
 
1282
        PyObject *_res = NULL;
 
1283
        OSErr _err;
 
1284
#ifndef AEObjectInit
 
1285
        PyMac_PRECHECK(AEObjectInit);
 
1286
#endif
 
1287
        if (!PyArg_ParseTuple(_args, ""))
 
1288
                return NULL;
 
1289
        _err = AEObjectInit();
 
1290
        if (_err != noErr) return PyMac_Error(_err);
 
1291
        Py_INCREF(Py_None);
 
1292
        _res = Py_None;
 
1293
        return _res;
 
1294
}
 
1295
 
 
1296
static PyObject *AE_AEDisposeToken(PyObject *_self, PyObject *_args)
 
1297
{
 
1298
        PyObject *_res = NULL;
 
1299
        OSErr _err;
 
1300
        AEDesc theToken;
 
1301
#ifndef AEDisposeToken
 
1302
        PyMac_PRECHECK(AEDisposeToken);
 
1303
#endif
 
1304
        if (!PyArg_ParseTuple(_args, ""))
 
1305
                return NULL;
 
1306
        _err = AEDisposeToken(&theToken);
 
1307
        if (_err != noErr) return PyMac_Error(_err);
 
1308
        _res = Py_BuildValue("O&",
 
1309
                             AEDesc_New, &theToken);
 
1310
        return _res;
 
1311
}
 
1312
 
 
1313
static PyObject *AE_AECallObjectAccessor(PyObject *_self, PyObject *_args)
 
1314
{
 
1315
        PyObject *_res = NULL;
 
1316
        OSErr _err;
 
1317
        DescType desiredClass;
 
1318
        AEDesc containerToken;
 
1319
        DescType containerClass;
 
1320
        DescType keyForm;
 
1321
        AEDesc keyData;
 
1322
        AEDesc token;
 
1323
#ifndef AECallObjectAccessor
 
1324
        PyMac_PRECHECK(AECallObjectAccessor);
 
1325
#endif
 
1326
        if (!PyArg_ParseTuple(_args, "O&O&O&O&O&",
 
1327
                              PyMac_GetOSType, &desiredClass,
 
1328
                              AEDesc_Convert, &containerToken,
 
1329
                              PyMac_GetOSType, &containerClass,
 
1330
                              PyMac_GetOSType, &keyForm,
 
1331
                              AEDesc_Convert, &keyData))
 
1332
                return NULL;
 
1333
        _err = AECallObjectAccessor(desiredClass,
 
1334
                                    &containerToken,
 
1335
                                    containerClass,
 
1336
                                    keyForm,
 
1337
                                    &keyData,
 
1338
                                    &token);
 
1339
        if (_err != noErr) return PyMac_Error(_err);
 
1340
        _res = Py_BuildValue("O&",
 
1341
                             AEDesc_New, &token);
 
1342
        return _res;
 
1343
}
 
1344
 
 
1345
static PyMethodDef AE_methods[] = {
 
1346
        {"AECoercePtr", (PyCFunction)AE_AECoercePtr, 1,
 
1347
         PyDoc_STR("(DescType typeCode, Buffer dataPtr, DescType toType) -> (AEDesc result)")},
 
1348
        {"AECreateDesc", (PyCFunction)AE_AECreateDesc, 1,
 
1349
         PyDoc_STR("(DescType typeCode, Buffer dataPtr) -> (AEDesc result)")},
 
1350
        {"AECreateList", (PyCFunction)AE_AECreateList, 1,
 
1351
         PyDoc_STR("(Buffer factoringPtr, Boolean isRecord) -> (AEDescList resultList)")},
 
1352
        {"AECreateAppleEvent", (PyCFunction)AE_AECreateAppleEvent, 1,
 
1353
         PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID, AEAddressDesc target, AEReturnID returnID, AETransactionID transactionID) -> (AppleEvent result)")},
 
1354
        {"AEReplaceDescData", (PyCFunction)AE_AEReplaceDescData, 1,
 
1355
         PyDoc_STR("(DescType typeCode, Buffer dataPtr) -> (AEDesc theAEDesc)")},
 
1356
        {"AEProcessAppleEvent", (PyCFunction)AE_AEProcessAppleEvent, 1,
 
1357
         PyDoc_STR("(EventRecord theEventRecord) -> None")},
 
1358
        {"AEGetInteractionAllowed", (PyCFunction)AE_AEGetInteractionAllowed, 1,
 
1359
         PyDoc_STR("() -> (AEInteractAllowed level)")},
 
1360
        {"AESetInteractionAllowed", (PyCFunction)AE_AESetInteractionAllowed, 1,
 
1361
         PyDoc_STR("(AEInteractAllowed level) -> None")},
 
1362
        {"AEInteractWithUser", (PyCFunction)AE_AEInteractWithUser, 1,
 
1363
         PyDoc_STR("(long timeOutInTicks) -> None")},
 
1364
        {"AEInstallEventHandler", (PyCFunction)AE_AEInstallEventHandler, 1,
 
1365
         PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID, EventHandler handler) -> None")},
 
1366
        {"AERemoveEventHandler", (PyCFunction)AE_AERemoveEventHandler, 1,
 
1367
         PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID) -> None")},
 
1368
        {"AEGetEventHandler", (PyCFunction)AE_AEGetEventHandler, 1,
 
1369
         PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID) -> (EventHandler handler)")},
 
1370
        {"AEInstallSpecialHandler", (PyCFunction)AE_AEInstallSpecialHandler, 1,
 
1371
         PyDoc_STR("(AEKeyword functionClass) -> None")},
 
1372
        {"AERemoveSpecialHandler", (PyCFunction)AE_AERemoveSpecialHandler, 1,
 
1373
         PyDoc_STR("(AEKeyword functionClass) -> None")},
 
1374
        {"AEManagerInfo", (PyCFunction)AE_AEManagerInfo, 1,
 
1375
         PyDoc_STR("(AEKeyword keyWord) -> (long result)")},
 
1376
        {"AEObjectInit", (PyCFunction)AE_AEObjectInit, 1,
 
1377
         PyDoc_STR("() -> None")},
 
1378
        {"AEDisposeToken", (PyCFunction)AE_AEDisposeToken, 1,
 
1379
         PyDoc_STR("() -> (AEDesc theToken)")},
 
1380
        {"AECallObjectAccessor", (PyCFunction)AE_AECallObjectAccessor, 1,
 
1381
         PyDoc_STR("(DescType desiredClass, AEDesc containerToken, DescType containerClass, DescType keyForm, AEDesc keyData) -> (AEDesc token)")},
 
1382
        {NULL, NULL, 0}
 
1383
};
 
1384
 
 
1385
 
 
1386
 
 
1387
static pascal OSErr
 
1388
GenericEventHandler(const AppleEvent *request, AppleEvent *reply, refcontype refcon)
 
1389
{
 
1390
        PyObject *handler = (PyObject *)refcon;
 
1391
        AEDescObject *requestObject, *replyObject;
 
1392
        PyObject *args, *res;
 
1393
        if ((requestObject = (AEDescObject *)AEDesc_New((AppleEvent *)request)) == NULL) {
 
1394
                return -1;
 
1395
        }
 
1396
        if ((replyObject = (AEDescObject *)AEDesc_New(reply)) == NULL) {
 
1397
                Py_DECREF(requestObject);
 
1398
                return -1;
 
1399
        }
 
1400
        if ((args = Py_BuildValue("OO", requestObject, replyObject)) == NULL) {
 
1401
                Py_DECREF(requestObject);
 
1402
                Py_DECREF(replyObject);
 
1403
                return -1;
 
1404
        }
 
1405
        res = PyEval_CallObject(handler, args);
 
1406
        requestObject->ob_itself.descriptorType = 'null';
 
1407
        requestObject->ob_itself.dataHandle = NULL;
 
1408
        replyObject->ob_itself.descriptorType = 'null';
 
1409
        replyObject->ob_itself.dataHandle = NULL;
 
1410
        Py_DECREF(args);
 
1411
        if (res == NULL) {
 
1412
                PySys_WriteStderr("Exception in AE event handler function\n");
 
1413
                PyErr_Print();
 
1414
                return -1;
 
1415
        }
 
1416
        Py_DECREF(res);
 
1417
        return noErr;
 
1418
}
 
1419
 
 
1420
PyObject *AEDesc_NewBorrowed(AEDesc *itself)
 
1421
{
 
1422
        PyObject *it;
 
1423
 
 
1424
        it = AEDesc_New(itself);
 
1425
        if (it)
 
1426
                ((AEDescObject *)it)->ob_owned = 0;
 
1427
        return (PyObject *)it;
 
1428
}
 
1429
 
 
1430
 
 
1431
 
 
1432
void init_AE(void)
 
1433
{
 
1434
        PyObject *m;
 
1435
        PyObject *d;
 
1436
 
 
1437
        upp_AEIdleProc = NewAEIdleUPP(AEIdleProc);
 
1438
        upp_GenericEventHandler = NewAEEventHandlerUPP(GenericEventHandler);
 
1439
        PyMac_INIT_TOOLBOX_OBJECT_NEW(AEDesc *, AEDesc_New);
 
1440
        PyMac_INIT_TOOLBOX_OBJECT_NEW(AEDesc *, AEDesc_NewBorrowed);
 
1441
        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(AEDesc, AEDesc_Convert);
 
1442
 
 
1443
        m = Py_InitModule("_AE", AE_methods);
 
1444
        d = PyModule_GetDict(m);
 
1445
        AE_Error = PyMac_GetOSErrException();
 
1446
        if (AE_Error == NULL ||
 
1447
            PyDict_SetItemString(d, "Error", AE_Error) != 0)
 
1448
                return;
 
1449
        AEDesc_Type.ob_type = &PyType_Type;
 
1450
        if (PyType_Ready(&AEDesc_Type) < 0) return;
 
1451
        Py_INCREF(&AEDesc_Type);
 
1452
        PyModule_AddObject(m, "AEDesc", (PyObject *)&AEDesc_Type);
 
1453
        /* Backward-compatible name */
 
1454
        Py_INCREF(&AEDesc_Type);
 
1455
        PyModule_AddObject(m, "AEDescType", (PyObject *)&AEDesc_Type);
 
1456
}
 
1457
 
 
1458
/* ========================= End module _AE ========================= */
 
1459