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                 PySys_WriteStderr("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 #define AEDesc_compare NULL
 817
 818 #define AEDesc_repr NULL
 819
 820 #define AEDesc_hash NULL
 821
 822 PyTypeObject AEDesc_Type = {
 823         PyObject_HEAD_INIT(&PyType_Type)
 824         0, /*ob_size*/
 825         "AEDesc", /*tp_name*/
 826         sizeof(AEDescObject), /*tp_basicsize*/
 827         0, /*tp_itemsize*/
 828         /* methods */
 829         (destructor) AEDesc_dealloc, /*tp_dealloc*/
 830         0, /*tp_print*/
 831         (getattrfunc) AEDesc_getattr, /*tp_getattr*/
 832         (setattrfunc) AEDesc_setattr, /*tp_setattr*/
 833         (cmpfunc) AEDesc_compare, /*tp_compare*/
 834         (reprfunc) AEDesc_repr, /*tp_repr*/
 835         (PyNumberMethods *)0, /* tp_as_number */
 836         (PySequenceMethods *)0, /* tp_as_sequence */
 837         (PyMappingMethods *)0, /* tp_as_mapping */
 838         (hashfunc) AEDesc_hash, /*tp_hash*/
 839 };
 840
 841 /* --------------------- End object type AEDesc --------------------- */
 842
 843
 844 static PyObject *AE_AEProcessAppleEvent(_self, _args)
 845         PyObject *_self;
 846         PyObject *_args;
 847 {
 848         PyObject *_res = NULL;
 849         OSErr _err;
 850         EventRecord theEventRecord;
 851         if (!PyArg_ParseTuple(_args, "O&",
 852                               PyMac_GetEventRecord, &theEventRecord))
 853                 return NULL;
 854         _err = AEProcessAppleEvent(&theEventRecord);
 855         if (_err != noErr) return PyMac_Error(_err);
 856         Py_INCREF(Py_None);
 857         _res = Py_None;
 858         return _res;
 859 }
 860
 861 static PyObject *AE_AEGetInteractionAllowed(_self, _args)
 862         PyObject *_self;
 863         PyObject *_args;
 864 {
 865         PyObject *_res = NULL;
 866         OSErr _err;
 867         AEInteractAllowed level;
 868         if (!PyArg_ParseTuple(_args, ""))
 869                 return NULL;
 870         _err = AEGetInteractionAllowed(&level);
 871         if (_err != noErr) return PyMac_Error(_err);
 872         _res = Py_BuildValue("b",
 873                              level);
 874         return _res;
 875 }
 876
 877 static PyObject *AE_AESetInteractionAllowed(_self, _args)
 878         PyObject *_self;
 879         PyObject *_args;
 880 {
 881         PyObject *_res = NULL;
 882         OSErr _err;
 883         AEInteractAllowed level;
 884         if (!PyArg_ParseTuple(_args, "b",
 885                               &level))
 886                 return NULL;
 887         _err = AESetInteractionAllowed(level);
 888         if (_err != noErr) return PyMac_Error(_err);
 889         Py_INCREF(Py_None);
 890         _res = Py_None;
 891         return _res;
 892 }
 893
 894 static PyObject *AE_AEInteractWithUser(_self, _args)
 895         PyObject *_self;
 896         PyObject *_args;
 897 {
 898         PyObject *_res = NULL;
 899         OSErr _err;
 900         long timeOutInTicks;
 901         if (!PyArg_ParseTuple(_args, "l",
 902                               &timeOutInTicks))
 903                 return NULL;
 904         _err = AEInteractWithUser(timeOutInTicks,
 905                                   (NMRecPtr)0,
 906                                   upp_AEIdleProc);
 907         if (_err != noErr) return PyMac_Error(_err);
 908         Py_INCREF(Py_None);
 909         _res = Py_None;
 910         return _res;
 911 }
 912
 913 static PyObject *AE_AEInstallEventHandler(_self, _args)
 914         PyObject *_self;
 915         PyObject *_args;
 916 {
 917         PyObject *_res = NULL;
 918         OSErr _err;
 919         AEEventClass theAEEventClass;
 920         AEEventID theAEEventID;
 921         AEEventHandlerUPP handler__proc__ = upp_GenericEventHandler;
 922         PyObject *handler;
 923         if (!PyArg_ParseTuple(_args, "O&O&O",
 924                               PyMac_GetOSType, &theAEEventClass,
 925                               PyMac_GetOSType, &theAEEventID,
 926                               &handler))
 927                 return NULL;
 928         _err = AEInstallEventHandler(theAEEventClass,
 929                                      theAEEventID,
 930                                      handler__proc__, (long)handler,
 931                                      0);
 932         if (_err != noErr) return PyMac_Error(_err);
 933         Py_INCREF(Py_None);
 934         _res = Py_None;
 935         Py_INCREF(handler); /* XXX leak, but needed */
 936         return _res;
 937 }
 938
 939 static PyObject *AE_AERemoveEventHandler(_self, _args)
 940         PyObject *_self;
 941         PyObject *_args;
 942 {
 943         PyObject *_res = NULL;
 944         OSErr _err;
 945         AEEventClass theAEEventClass;
 946         AEEventID theAEEventID;
 947         if (!PyArg_ParseTuple(_args, "O&O&",
 948                               PyMac_GetOSType, &theAEEventClass,
 949                               PyMac_GetOSType, &theAEEventID))
 950                 return NULL;
 951         _err = AERemoveEventHandler(theAEEventClass,
 952                                     theAEEventID,
 953                                     upp_GenericEventHandler,
 954                                     0);
 955         if (_err != noErr) return PyMac_Error(_err);
 956         Py_INCREF(Py_None);
 957         _res = Py_None;
 958         return _res;
 959 }
 960
 961 static PyObject *AE_AEGetEventHandler(_self, _args)
 962         PyObject *_self;
 963         PyObject *_args;
 964 {
 965         PyObject *_res = NULL;
 966         OSErr _err;
 967         AEEventClass theAEEventClass;
 968         AEEventID theAEEventID;
 969         AEEventHandlerUPP handler__proc__ = upp_GenericEventHandler;
 970         PyObject *handler;
 971         if (!PyArg_ParseTuple(_args, "O&O&",
 972                               PyMac_GetOSType, &theAEEventClass,
 973                               PyMac_GetOSType, &theAEEventID))
 974                 return NULL;
 975         _err = AEGetEventHandler(theAEEventClass,
 976                                  theAEEventID,
 977                                  &handler__proc__, (long *)&handler,
 978                                  0);
 979         if (_err != noErr) return PyMac_Error(_err);
 980         _res = Py_BuildValue("O",
 981                              handler);
 982         Py_INCREF(handler); /* XXX leak, but needed */
 983         return _res;
 984 }
 985
 986 static PyObject *AE_AEManagerInfo(_self, _args)
 987         PyObject *_self;
 988         PyObject *_args;
 989 {
 990         PyObject *_res = NULL;
 991         OSErr _err;
 992         AEKeyword keyWord;
 993         long result;
 994         if (!PyArg_ParseTuple(_args, "O&",
 995                               PyMac_GetOSType, &keyWord))
 996                 return NULL;
 997         _err = AEManagerInfo(keyWord,
 998                              &result);
 999         if (_err != noErr) return PyMac_Error(_err);
1000         _res = Py_BuildValue("l",
1001                              result);
1002         return _res;
1003 }
1004
1005 static PyObject *AE_AECoercePtr(_self, _args)
1006         PyObject *_self;
1007         PyObject *_args;
1008 {
1009         PyObject *_res = NULL;
1010         OSErr _err;
1011         DescType typeCode;
1012         char *dataPtr__in__;
1013         long dataPtr__len__;
1014         int dataPtr__in_len__;
1015         DescType toType;
1016         AEDesc result;
1017         if (!PyArg_ParseTuple(_args, "O&s#O&",
1018                               PyMac_GetOSType, &typeCode,
1019                               &dataPtr__in__, &dataPtr__in_len__,
1020                               PyMac_GetOSType, &toType))
1021                 return NULL;
1022         dataPtr__len__ = dataPtr__in_len__;
1023         _err = AECoercePtr(typeCode,
1024                            dataPtr__in__, dataPtr__len__,
1025                            toType,
1026                            &result);
1027         if (_err != noErr) return PyMac_Error(_err);
1028         _res = Py_BuildValue("O&",
1029                              AEDesc_New, &result);
1030  dataPtr__error__: ;
1031         return _res;
1032 }
1033
1034 static PyObject *AE_AECreateDesc(_self, _args)
1035         PyObject *_self;
1036         PyObject *_args;
1037 {
1038         PyObject *_res = NULL;
1039         OSErr _err;
1040         DescType typeCode;
1041         char *dataPtr__in__;
1042         long dataPtr__len__;
1043         int dataPtr__in_len__;
1044         AEDesc result;
1045         if (!PyArg_ParseTuple(_args, "O&s#",
1046                               PyMac_GetOSType, &typeCode,
1047                               &dataPtr__in__, &dataPtr__in_len__))
1048                 return NULL;
1049         dataPtr__len__ = dataPtr__in_len__;
1050         _err = AECreateDesc(typeCode,
1051                             dataPtr__in__, dataPtr__len__,
1052                             &result);
1053         if (_err != noErr) return PyMac_Error(_err);
1054         _res = Py_BuildValue("O&",
1055                              AEDesc_New, &result);
1056  dataPtr__error__: ;
1057         return _res;
1058 }
1059
1060 static PyObject *AE_AECreateList(_self, _args)
1061         PyObject *_self;
1062         PyObject *_args;
1063 {
1064         PyObject *_res = NULL;
1065         OSErr _err;
1066         char *factoringPtr__in__;
1067         long factoringPtr__len__;
1068         int factoringPtr__in_len__;
1069         Boolean isRecord;
1070         AEDescList resultList;
1071         if (!PyArg_ParseTuple(_args, "s#b",
1072                               &factoringPtr__in__, &factoringPtr__in_len__,
1073                               &isRecord))
1074                 return NULL;
1075         factoringPtr__len__ = factoringPtr__in_len__;
1076         _err = AECreateList(factoringPtr__in__, factoringPtr__len__,
1077                             isRecord,
1078                             &resultList);
1079         if (_err != noErr) return PyMac_Error(_err);
1080         _res = Py_BuildValue("O&",
1081                              AEDesc_New, &resultList);
1082  factoringPtr__error__: ;
1083         return _res;
1084 }
1085
1086 static PyObject *AE_AECreateAppleEvent(_self, _args)
1087         PyObject *_self;
1088         PyObject *_args;
1089 {
1090         PyObject *_res = NULL;
1091         OSErr _err;
1092         AEEventClass theAEEventClass;
1093         AEEventID theAEEventID;
1094         AEAddressDesc target;
1095         AEReturnID returnID;
1096         AETransactionID transactionID;
1097         AppleEvent result;
1098         if (!PyArg_ParseTuple(_args, "O&O&O&hh",
1099                               PyMac_GetOSType, &theAEEventClass,
1100                               PyMac_GetOSType, &theAEEventID,
1101                               AEDesc_Convert, &target,
1102                               &returnID,
1103                               &transactionID))
1104                 return NULL;
1105         _err = AECreateAppleEvent(theAEEventClass,
1106                                   theAEEventID,
1107                                   &target,
1108                                   returnID,
1109                                   transactionID,
1110                                   &result);
1111         if (_err != noErr) return PyMac_Error(_err);
1112         _res = Py_BuildValue("O&",
1113                              AEDesc_New, &result);
1114         return _res;
1115 }
1116
1117 static PyMethodDef AE_methods[] = {
1118         {"AEProcessAppleEvent", (PyCFunction)AE_AEProcessAppleEvent, 1,
1119          "(EventRecord theEventRecord) -> None"},
1120         {"AEGetInteractionAllowed", (PyCFunction)AE_AEGetInteractionAllowed, 1,
1121          "() -> (AEInteractAllowed level)"},
1122         {"AESetInteractionAllowed", (PyCFunction)AE_AESetInteractionAllowed, 1,
1123          "(AEInteractAllowed level) -> None"},
1124         {"AEInteractWithUser", (PyCFunction)AE_AEInteractWithUser, 1,
1125          "(long timeOutInTicks) -> None"},
1126         {"AEInstallEventHandler", (PyCFunction)AE_AEInstallEventHandler, 1,
1127          "(AEEventClass theAEEventClass, AEEventID theAEEventID, EventHandler handler) -> None"},
1128         {"AERemoveEventHandler", (PyCFunction)AE_AERemoveEventHandler, 1,
1129          "(AEEventClass theAEEventClass, AEEventID theAEEventID) -> None"},
1130         {"AEGetEventHandler", (PyCFunction)AE_AEGetEventHandler, 1,
1131          "(AEEventClass theAEEventClass, AEEventID theAEEventID) -> (EventHandler handler)"},
1132         {"AEManagerInfo", (PyCFunction)AE_AEManagerInfo, 1,
1133          "(AEKeyword keyWord) -> (long result)"},
1134         {"AECoercePtr", (PyCFunction)AE_AECoercePtr, 1,
1135          "(DescType typeCode, Buffer dataPtr, DescType toType) -> (AEDesc result)"},
1136         {"AECreateDesc", (PyCFunction)AE_AECreateDesc, 1,
1137          "(DescType typeCode, Buffer dataPtr) -> (AEDesc result)"},
1138         {"AECreateList", (PyCFunction)AE_AECreateList, 1,
1139          "(Buffer factoringPtr, Boolean isRecord) -> (AEDescList resultList)"},
1140         {"AECreateAppleEvent", (PyCFunction)AE_AECreateAppleEvent, 1,
1141          "(AEEventClass theAEEventClass, AEEventID theAEEventID, AEAddressDesc target, AEReturnID returnID, AETransactionID transactionID) -> (AppleEvent result)"},
1142         {NULL, NULL, 0}
1143 };
1144
1145
1146
1147 static pascal OSErr
1148 GenericEventHandler(AppleEvent *request, AppleEvent *reply, long refcon)
1149 {
1150         PyObject *handler = (PyObject *)refcon;
1151         AEDescObject *requestObject, *replyObject;
1152         PyObject *args, *res;
1153         if ((requestObject = (AEDescObject *)AEDesc_New(request)) == NULL) {
1154                 return -1;
1155         }
1156         if ((replyObject = (AEDescObject *)AEDesc_New(reply)) == NULL) {
1157                 Py_DECREF(requestObject);
1158                 return -1;
1159         }
1160         if ((args = Py_BuildValue("OO", requestObject, replyObject)) == NULL) {
1161                 Py_DECREF(requestObject);
1162                 Py_DECREF(replyObject);
1163                 return -1;
1164         }
1165         res = PyEval_CallObject(handler, args);
1166         requestObject->ob_itself.descriptorType = 'null';
1167         requestObject->ob_itself.dataHandle = NULL;
1168         replyObject->ob_itself.descriptorType = 'null';
1169         replyObject->ob_itself.dataHandle = NULL;
1170         Py_DECREF(args);
1171         if (res == NULL)
1172                 return -1;
1173         Py_DECREF(res);
1174         return noErr;
1175 }
1176
1177
1178 void initAE()
1179 {
1180         PyObject *m;
1181         PyObject *d;
1182
1183
1184
1185                 upp_AEIdleProc = NewAEIdleProc(AEIdleProc);
1186                 upp_GenericEventHandler = NewAEEventHandlerProc(GenericEventHandler);
1187
1188
1189         m = Py_InitModule("AE", AE_methods);
1190         d = PyModule_GetDict(m);
1191         AE_Error = PyMac_GetOSErrException();
1192         if (AE_Error == NULL ||
1193             PyDict_SetItemString(d, "Error", AE_Error) != 0)
1194                 Py_FatalError("can't initialize AE.Error");
1195         AEDesc_Type.ob_type = &PyType_Type;
1196         Py_INCREF(&AEDesc_Type);
1197         if (PyDict_SetItemString(d, "AEDescType", (PyObject *)&AEDesc_Type) != 0)
1198                 Py_FatalError("can't initialize AEDescType");
1199 }
1200
1201 /* ========================= End module AE ========================== */
1202