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