Mac/Modules/ae/AEmodule.c

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