Mac/Modules/ae/AEmodule.c

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