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