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