Mac/Modules/ae/_AEmodule.c

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