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,