1460 lines
42 KiB
C
1460 lines
42 KiB
C
|
|
/* =========================== Module _AE =========================== */
|
|
|
|
#include "Python.h"
|
|
|
|
|
|
|
|
#include "pymactoolbox.h"
|
|
|
|
#ifndef HAVE_OSX105_SDK
|
|
typedef SInt32 SRefCon;
|
|
#endif
|
|
|
|
/* Macro to test whether a weak-loaded CFM function exists */
|
|
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
|
|
PyErr_SetString(PyExc_NotImplementedError, \
|
|
"Not available in this shared library/OS version"); \
|
|
return NULL; \
|
|
}} while(0)
|
|
|
|
|
|
#include <Carbon/Carbon.h>
|
|
|
|
#ifdef USE_TOOLBOX_OBJECT_GLUE
|
|
extern PyObject *_AEDesc_New(AEDesc *);
|
|
extern int _AEDesc_Convert(PyObject *, AEDesc *);
|
|
|
|
#define AEDesc_New _AEDesc_New
|
|
#define AEDesc_NewBorrowed _AEDesc_NewBorrowed
|
|
#define AEDesc_Convert _AEDesc_Convert
|
|
#endif
|
|
|
|
typedef long refcontype;
|
|
|
|
static pascal OSErr GenericEventHandler(const AppleEvent *request, AppleEvent *reply, refcontype refcon); /* Forward */
|
|
|
|
AEEventHandlerUPP upp_GenericEventHandler;
|
|
|
|
static pascal Boolean AEIdleProc(EventRecord *theEvent, long *sleepTime, RgnHandle *mouseRgn)
|
|
{
|
|
if ( PyOS_InterruptOccurred() )
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
AEIdleUPP upp_AEIdleProc;
|
|
|
|
static PyObject *AE_Error;
|
|
|
|
/* ----------------------- Object type AEDesc ----------------------- */
|
|
|
|
PyTypeObject AEDesc_Type;
|
|
|
|
#define AEDesc_Check(x) ((x)->ob_type == &AEDesc_Type || PyObject_TypeCheck((x), &AEDesc_Type))
|
|
|
|
typedef struct AEDescObject {
|
|
PyObject_HEAD
|
|
AEDesc ob_itself;
|
|
int ob_owned;
|
|
} AEDescObject;
|
|
|
|
PyObject *AEDesc_New(AEDesc *itself)
|
|
{
|
|
AEDescObject *it;
|
|
it = PyObject_NEW(AEDescObject, &AEDesc_Type);
|
|
if (it == NULL) return NULL;
|
|
it->ob_itself = *itself;
|
|
it->ob_owned = 1;
|
|
return (PyObject *)it;
|
|
}
|
|
|
|
int AEDesc_Convert(PyObject *v, AEDesc *p_itself)
|
|
{
|
|
if (!AEDesc_Check(v))
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, "AEDesc required");
|
|
return 0;
|
|
}
|
|
*p_itself = ((AEDescObject *)v)->ob_itself;
|
|
return 1;
|
|
}
|
|
|
|
static void AEDesc_dealloc(AEDescObject *self)
|
|
{
|
|
if (self->ob_owned) AEDisposeDesc(&self->ob_itself);
|
|
self->ob_type->tp_free((PyObject *)self);
|
|
}
|
|
|
|
static PyObject *AEDesc_AECoerceDesc(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
DescType toType;
|
|
AEDesc result;
|
|
#ifndef AECoerceDesc
|
|
PyMac_PRECHECK(AECoerceDesc);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetOSType, &toType))
|
|
return NULL;
|
|
_err = AECoerceDesc(&_self->ob_itself,
|
|
toType,
|
|
&result);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
AEDesc_New, &result);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEDuplicateDesc(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEDesc result;
|
|
#ifndef AEDuplicateDesc
|
|
PyMac_PRECHECK(AEDuplicateDesc);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = AEDuplicateDesc(&_self->ob_itself,
|
|
&result);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
AEDesc_New, &result);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AECountItems(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
long theCount;
|
|
#ifndef AECountItems
|
|
PyMac_PRECHECK(AECountItems);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = AECountItems(&_self->ob_itself,
|
|
&theCount);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("l",
|
|
theCount);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEPutPtr(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
long index;
|
|
DescType typeCode;
|
|
char *dataPtr__in__;
|
|
long dataPtr__len__;
|
|
int dataPtr__in_len__;
|
|
#ifndef AEPutPtr
|
|
PyMac_PRECHECK(AEPutPtr);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "lO&s#",
|
|
&index,
|
|
PyMac_GetOSType, &typeCode,
|
|
&dataPtr__in__, &dataPtr__in_len__))
|
|
return NULL;
|
|
dataPtr__len__ = dataPtr__in_len__;
|
|
_err = AEPutPtr(&_self->ob_itself,
|
|
index,
|
|
typeCode,
|
|
dataPtr__in__, dataPtr__len__);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEPutDesc(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
long index;
|
|
AEDesc theAEDesc;
|
|
#ifndef AEPutDesc
|
|
PyMac_PRECHECK(AEPutDesc);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "lO&",
|
|
&index,
|
|
AEDesc_Convert, &theAEDesc))
|
|
return NULL;
|
|
_err = AEPutDesc(&_self->ob_itself,
|
|
index,
|
|
&theAEDesc);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEGetNthPtr(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
long index;
|
|
DescType desiredType;
|
|
AEKeyword theAEKeyword;
|
|
DescType typeCode;
|
|
char *dataPtr__out__;
|
|
long dataPtr__len__;
|
|
int dataPtr__in_len__;
|
|
#ifndef AEGetNthPtr
|
|
PyMac_PRECHECK(AEGetNthPtr);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "lO&i",
|
|
&index,
|
|
PyMac_GetOSType, &desiredType,
|
|
&dataPtr__in_len__))
|
|
return NULL;
|
|
if ((dataPtr__out__ = malloc(dataPtr__in_len__)) == NULL)
|
|
{
|
|
PyErr_NoMemory();
|
|
goto dataPtr__error__;
|
|
}
|
|
dataPtr__len__ = dataPtr__in_len__;
|
|
_err = AEGetNthPtr(&_self->ob_itself,
|
|
index,
|
|
desiredType,
|
|
&theAEKeyword,
|
|
&typeCode,
|
|
dataPtr__out__, dataPtr__len__, &dataPtr__len__);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&O&s#",
|
|
PyMac_BuildOSType, theAEKeyword,
|
|
PyMac_BuildOSType, typeCode,
|
|
dataPtr__out__, (int)dataPtr__len__);
|
|
free(dataPtr__out__);
|
|
dataPtr__error__: ;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEGetNthDesc(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
long index;
|
|
DescType desiredType;
|
|
AEKeyword theAEKeyword;
|
|
AEDesc result;
|
|
#ifndef AEGetNthDesc
|
|
PyMac_PRECHECK(AEGetNthDesc);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "lO&",
|
|
&index,
|
|
PyMac_GetOSType, &desiredType))
|
|
return NULL;
|
|
_err = AEGetNthDesc(&_self->ob_itself,
|
|
index,
|
|
desiredType,
|
|
&theAEKeyword,
|
|
&result);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&O&",
|
|
PyMac_BuildOSType, theAEKeyword,
|
|
AEDesc_New, &result);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AESizeOfNthItem(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
long index;
|
|
DescType typeCode;
|
|
Size dataSize;
|
|
#ifndef AESizeOfNthItem
|
|
PyMac_PRECHECK(AESizeOfNthItem);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "l",
|
|
&index))
|
|
return NULL;
|
|
_err = AESizeOfNthItem(&_self->ob_itself,
|
|
index,
|
|
&typeCode,
|
|
&dataSize);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&l",
|
|
PyMac_BuildOSType, typeCode,
|
|
dataSize);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEDeleteItem(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
long index;
|
|
#ifndef AEDeleteItem
|
|
PyMac_PRECHECK(AEDeleteItem);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "l",
|
|
&index))
|
|
return NULL;
|
|
_err = AEDeleteItem(&_self->ob_itself,
|
|
index);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEPutParamPtr(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEKeyword theAEKeyword;
|
|
DescType typeCode;
|
|
char *dataPtr__in__;
|
|
long dataPtr__len__;
|
|
int dataPtr__in_len__;
|
|
#ifndef AEPutParamPtr
|
|
PyMac_PRECHECK(AEPutParamPtr);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&s#",
|
|
PyMac_GetOSType, &theAEKeyword,
|
|
PyMac_GetOSType, &typeCode,
|
|
&dataPtr__in__, &dataPtr__in_len__))
|
|
return NULL;
|
|
dataPtr__len__ = dataPtr__in_len__;
|
|
_err = AEPutParamPtr(&_self->ob_itself,
|
|
theAEKeyword,
|
|
typeCode,
|
|
dataPtr__in__, dataPtr__len__);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEPutParamDesc(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEKeyword theAEKeyword;
|
|
AEDesc theAEDesc;
|
|
#ifndef AEPutParamDesc
|
|
PyMac_PRECHECK(AEPutParamDesc);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
PyMac_GetOSType, &theAEKeyword,
|
|
AEDesc_Convert, &theAEDesc))
|
|
return NULL;
|
|
_err = AEPutParamDesc(&_self->ob_itself,
|
|
theAEKeyword,
|
|
&theAEDesc);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEGetParamPtr(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEKeyword theAEKeyword;
|
|
DescType desiredType;
|
|
DescType typeCode;
|
|
char *dataPtr__out__;
|
|
long dataPtr__len__;
|
|
int dataPtr__in_len__;
|
|
#ifndef AEGetParamPtr
|
|
PyMac_PRECHECK(AEGetParamPtr);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&i",
|
|
PyMac_GetOSType, &theAEKeyword,
|
|
PyMac_GetOSType, &desiredType,
|
|
&dataPtr__in_len__))
|
|
return NULL;
|
|
if ((dataPtr__out__ = malloc(dataPtr__in_len__)) == NULL)
|
|
{
|
|
PyErr_NoMemory();
|
|
goto dataPtr__error__;
|
|
}
|
|
dataPtr__len__ = dataPtr__in_len__;
|
|
_err = AEGetParamPtr(&_self->ob_itself,
|
|
theAEKeyword,
|
|
desiredType,
|
|
&typeCode,
|
|
dataPtr__out__, dataPtr__len__, &dataPtr__len__);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&s#",
|
|
PyMac_BuildOSType, typeCode,
|
|
dataPtr__out__, (int)dataPtr__len__);
|
|
free(dataPtr__out__);
|
|
dataPtr__error__: ;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEGetParamDesc(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEKeyword theAEKeyword;
|
|
DescType desiredType;
|
|
AEDesc result;
|
|
#ifndef AEGetParamDesc
|
|
PyMac_PRECHECK(AEGetParamDesc);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
PyMac_GetOSType, &theAEKeyword,
|
|
PyMac_GetOSType, &desiredType))
|
|
return NULL;
|
|
_err = AEGetParamDesc(&_self->ob_itself,
|
|
theAEKeyword,
|
|
desiredType,
|
|
&result);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
AEDesc_New, &result);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AESizeOfParam(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEKeyword theAEKeyword;
|
|
DescType typeCode;
|
|
Size dataSize;
|
|
#ifndef AESizeOfParam
|
|
PyMac_PRECHECK(AESizeOfParam);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetOSType, &theAEKeyword))
|
|
return NULL;
|
|
_err = AESizeOfParam(&_self->ob_itself,
|
|
theAEKeyword,
|
|
&typeCode,
|
|
&dataSize);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&l",
|
|
PyMac_BuildOSType, typeCode,
|
|
dataSize);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEDeleteParam(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEKeyword theAEKeyword;
|
|
#ifndef AEDeleteParam
|
|
PyMac_PRECHECK(AEDeleteParam);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetOSType, &theAEKeyword))
|
|
return NULL;
|
|
_err = AEDeleteParam(&_self->ob_itself,
|
|
theAEKeyword);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEGetAttributePtr(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEKeyword theAEKeyword;
|
|
DescType desiredType;
|
|
DescType typeCode;
|
|
char *dataPtr__out__;
|
|
long dataPtr__len__;
|
|
int dataPtr__in_len__;
|
|
#ifndef AEGetAttributePtr
|
|
PyMac_PRECHECK(AEGetAttributePtr);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&i",
|
|
PyMac_GetOSType, &theAEKeyword,
|
|
PyMac_GetOSType, &desiredType,
|
|
&dataPtr__in_len__))
|
|
return NULL;
|
|
if ((dataPtr__out__ = malloc(dataPtr__in_len__)) == NULL)
|
|
{
|
|
PyErr_NoMemory();
|
|
goto dataPtr__error__;
|
|
}
|
|
dataPtr__len__ = dataPtr__in_len__;
|
|
_err = AEGetAttributePtr(&_self->ob_itself,
|
|
theAEKeyword,
|
|
desiredType,
|
|
&typeCode,
|
|
dataPtr__out__, dataPtr__len__, &dataPtr__len__);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&s#",
|
|
PyMac_BuildOSType, typeCode,
|
|
dataPtr__out__, (int)dataPtr__len__);
|
|
free(dataPtr__out__);
|
|
dataPtr__error__: ;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEGetAttributeDesc(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEKeyword theAEKeyword;
|
|
DescType desiredType;
|
|
AEDesc result;
|
|
#ifndef AEGetAttributeDesc
|
|
PyMac_PRECHECK(AEGetAttributeDesc);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
PyMac_GetOSType, &theAEKeyword,
|
|
PyMac_GetOSType, &desiredType))
|
|
return NULL;
|
|
_err = AEGetAttributeDesc(&_self->ob_itself,
|
|
theAEKeyword,
|
|
desiredType,
|
|
&result);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
AEDesc_New, &result);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AESizeOfAttribute(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEKeyword theAEKeyword;
|
|
DescType typeCode;
|
|
Size dataSize;
|
|
#ifndef AESizeOfAttribute
|
|
PyMac_PRECHECK(AESizeOfAttribute);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetOSType, &theAEKeyword))
|
|
return NULL;
|
|
_err = AESizeOfAttribute(&_self->ob_itself,
|
|
theAEKeyword,
|
|
&typeCode,
|
|
&dataSize);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&l",
|
|
PyMac_BuildOSType, typeCode,
|
|
dataSize);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEPutAttributePtr(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEKeyword theAEKeyword;
|
|
DescType typeCode;
|
|
char *dataPtr__in__;
|
|
long dataPtr__len__;
|
|
int dataPtr__in_len__;
|
|
#ifndef AEPutAttributePtr
|
|
PyMac_PRECHECK(AEPutAttributePtr);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&s#",
|
|
PyMac_GetOSType, &theAEKeyword,
|
|
PyMac_GetOSType, &typeCode,
|
|
&dataPtr__in__, &dataPtr__in_len__))
|
|
return NULL;
|
|
dataPtr__len__ = dataPtr__in_len__;
|
|
_err = AEPutAttributePtr(&_self->ob_itself,
|
|
theAEKeyword,
|
|
typeCode,
|
|
dataPtr__in__, dataPtr__len__);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEPutAttributeDesc(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEKeyword theAEKeyword;
|
|
AEDesc theAEDesc;
|
|
#ifndef AEPutAttributeDesc
|
|
PyMac_PRECHECK(AEPutAttributeDesc);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
PyMac_GetOSType, &theAEKeyword,
|
|
AEDesc_Convert, &theAEDesc))
|
|
return NULL;
|
|
_err = AEPutAttributeDesc(&_self->ob_itself,
|
|
theAEKeyword,
|
|
&theAEDesc);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEGetDescDataSize(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
Size _rv;
|
|
#ifndef AEGetDescDataSize
|
|
PyMac_PRECHECK(AEGetDescDataSize);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_rv = AEGetDescDataSize(&_self->ob_itself);
|
|
_res = Py_BuildValue("l",
|
|
_rv);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AESend(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AppleEvent reply;
|
|
AESendMode sendMode;
|
|
AESendPriority sendPriority;
|
|
long timeOutInTicks;
|
|
#ifndef AESend
|
|
PyMac_PRECHECK(AESend);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "lhl",
|
|
&sendMode,
|
|
&sendPriority,
|
|
&timeOutInTicks))
|
|
return NULL;
|
|
_err = AESend(&_self->ob_itself,
|
|
&reply,
|
|
sendMode,
|
|
sendPriority,
|
|
timeOutInTicks,
|
|
upp_AEIdleProc,
|
|
(AEFilterUPP)0);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
AEDesc_New, &reply);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEResetTimer(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
#ifndef AEResetTimer
|
|
PyMac_PRECHECK(AEResetTimer);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = AEResetTimer(&_self->ob_itself);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AESuspendTheCurrentEvent(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
#ifndef AESuspendTheCurrentEvent
|
|
PyMac_PRECHECK(AESuspendTheCurrentEvent);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = AESuspendTheCurrentEvent(&_self->ob_itself);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEResumeTheCurrentEvent(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AppleEvent reply;
|
|
AEEventHandlerUPP dispatcher__proc__ = upp_GenericEventHandler;
|
|
PyObject *dispatcher;
|
|
#ifndef AEResumeTheCurrentEvent
|
|
PyMac_PRECHECK(AEResumeTheCurrentEvent);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O",
|
|
AEDesc_Convert, &reply,
|
|
&dispatcher))
|
|
return NULL;
|
|
_err = AEResumeTheCurrentEvent(&_self->ob_itself,
|
|
&reply,
|
|
dispatcher__proc__,
|
|
(SRefCon)dispatcher);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
Py_INCREF(dispatcher); /* XXX leak, but needed */
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEGetTheCurrentEvent(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
#ifndef AEGetTheCurrentEvent
|
|
PyMac_PRECHECK(AEGetTheCurrentEvent);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = AEGetTheCurrentEvent(&_self->ob_itself);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AESetTheCurrentEvent(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
#ifndef AESetTheCurrentEvent
|
|
PyMac_PRECHECK(AESetTheCurrentEvent);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = AESetTheCurrentEvent(&_self->ob_itself);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AEResolve(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short callbackFlags;
|
|
AEDesc theToken;
|
|
#ifndef AEResolve
|
|
PyMac_PRECHECK(AEResolve);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&callbackFlags))
|
|
return NULL;
|
|
_err = AEResolve(&_self->ob_itself,
|
|
callbackFlags,
|
|
&theToken);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
AEDesc_New, &theToken);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AEDesc_AutoDispose(AEDescObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
|
|
int onoff, old;
|
|
if (!PyArg_ParseTuple(_args, "i", &onoff))
|
|
return NULL;
|
|
old = _self->ob_owned;
|
|
_self->ob_owned = onoff;
|
|
_res = Py_BuildValue("i", old);
|
|
return _res;
|
|
|
|
}
|
|
|
|
static PyMethodDef AEDesc_methods[] = {
|
|
{"AECoerceDesc", (PyCFunction)AEDesc_AECoerceDesc, 1,
|
|
PyDoc_STR("(DescType toType) -> (AEDesc result)")},
|
|
{"AEDuplicateDesc", (PyCFunction)AEDesc_AEDuplicateDesc, 1,
|
|
PyDoc_STR("() -> (AEDesc result)")},
|
|
{"AECountItems", (PyCFunction)AEDesc_AECountItems, 1,
|
|
PyDoc_STR("() -> (long theCount)")},
|
|
{"AEPutPtr", (PyCFunction)AEDesc_AEPutPtr, 1,
|
|
PyDoc_STR("(long index, DescType typeCode, Buffer dataPtr) -> None")},
|
|
{"AEPutDesc", (PyCFunction)AEDesc_AEPutDesc, 1,
|
|
PyDoc_STR("(long index, AEDesc theAEDesc) -> None")},
|
|
{"AEGetNthPtr", (PyCFunction)AEDesc_AEGetNthPtr, 1,
|
|
PyDoc_STR("(long index, DescType desiredType, Buffer dataPtr) -> (AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr)")},
|
|
{"AEGetNthDesc", (PyCFunction)AEDesc_AEGetNthDesc, 1,
|
|
PyDoc_STR("(long index, DescType desiredType) -> (AEKeyword theAEKeyword, AEDesc result)")},
|
|
{"AESizeOfNthItem", (PyCFunction)AEDesc_AESizeOfNthItem, 1,
|
|
PyDoc_STR("(long index) -> (DescType typeCode, Size dataSize)")},
|
|
{"AEDeleteItem", (PyCFunction)AEDesc_AEDeleteItem, 1,
|
|
PyDoc_STR("(long index) -> None")},
|
|
{"AEPutParamPtr", (PyCFunction)AEDesc_AEPutParamPtr, 1,
|
|
PyDoc_STR("(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None")},
|
|
{"AEPutParamDesc", (PyCFunction)AEDesc_AEPutParamDesc, 1,
|
|
PyDoc_STR("(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None")},
|
|
{"AEGetParamPtr", (PyCFunction)AEDesc_AEGetParamPtr, 1,
|
|
PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)")},
|
|
{"AEGetParamDesc", (PyCFunction)AEDesc_AEGetParamDesc, 1,
|
|
PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)")},
|
|
{"AESizeOfParam", (PyCFunction)AEDesc_AESizeOfParam, 1,
|
|
PyDoc_STR("(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)")},
|
|
{"AEDeleteParam", (PyCFunction)AEDesc_AEDeleteParam, 1,
|
|
PyDoc_STR("(AEKeyword theAEKeyword) -> None")},
|
|
{"AEGetAttributePtr", (PyCFunction)AEDesc_AEGetAttributePtr, 1,
|
|
PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)")},
|
|
{"AEGetAttributeDesc", (PyCFunction)AEDesc_AEGetAttributeDesc, 1,
|
|
PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)")},
|
|
{"AESizeOfAttribute", (PyCFunction)AEDesc_AESizeOfAttribute, 1,
|
|
PyDoc_STR("(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)")},
|
|
{"AEPutAttributePtr", (PyCFunction)AEDesc_AEPutAttributePtr, 1,
|
|
PyDoc_STR("(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None")},
|
|
{"AEPutAttributeDesc", (PyCFunction)AEDesc_AEPutAttributeDesc, 1,
|
|
PyDoc_STR("(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None")},
|
|
{"AEGetDescDataSize", (PyCFunction)AEDesc_AEGetDescDataSize, 1,
|
|
PyDoc_STR("() -> (Size _rv)")},
|
|
{"AESend", (PyCFunction)AEDesc_AESend, 1,
|
|
PyDoc_STR("(AESendMode sendMode, AESendPriority sendPriority, long timeOutInTicks) -> (AppleEvent reply)")},
|
|
{"AEResetTimer", (PyCFunction)AEDesc_AEResetTimer, 1,
|
|
PyDoc_STR("() -> None")},
|
|
{"AESuspendTheCurrentEvent", (PyCFunction)AEDesc_AESuspendTheCurrentEvent, 1,
|
|
PyDoc_STR("() -> None")},
|
|
{"AEResumeTheCurrentEvent", (PyCFunction)AEDesc_AEResumeTheCurrentEvent, 1,
|
|
PyDoc_STR("(AppleEvent reply, EventHandler dispatcher) -> None")},
|
|
{"AEGetTheCurrentEvent", (PyCFunction)AEDesc_AEGetTheCurrentEvent, 1,
|
|
PyDoc_STR("() -> None")},
|
|
{"AESetTheCurrentEvent", (PyCFunction)AEDesc_AESetTheCurrentEvent, 1,
|
|
PyDoc_STR("() -> None")},
|
|
{"AEResolve", (PyCFunction)AEDesc_AEResolve, 1,
|
|
PyDoc_STR("(short callbackFlags) -> (AEDesc theToken)")},
|
|
{"AutoDispose", (PyCFunction)AEDesc_AutoDispose, 1,
|
|
PyDoc_STR("(int)->int. Automatically AEDisposeDesc the object on Python object cleanup")},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
static PyObject *AEDesc_get_type(AEDescObject *self, void *closure)
|
|
{
|
|
return PyMac_BuildOSType(self->ob_itself.descriptorType);
|
|
}
|
|
|
|
#define AEDesc_set_type NULL
|
|
|
|
static PyObject *AEDesc_get_data(AEDescObject *self, void *closure)
|
|
{
|
|
PyObject *res;
|
|
Size size;
|
|
char *ptr;
|
|
OSErr err;
|
|
|
|
size = AEGetDescDataSize(&self->ob_itself);
|
|
if ( (res = PyString_FromStringAndSize(NULL, size)) == NULL )
|
|
return NULL;
|
|
if ( (ptr = PyString_AsString(res)) == NULL )
|
|
return NULL;
|
|
if ( (err=AEGetDescData(&self->ob_itself, ptr, size)) < 0 )
|
|
return PyMac_Error(err);
|
|
return res;
|
|
}
|
|
|
|
#define AEDesc_set_data NULL
|
|
|
|
static PyGetSetDef AEDesc_getsetlist[] = {
|
|
{"type", (getter)AEDesc_get_type, (setter)AEDesc_set_type, "Type of this AEDesc"},
|
|
{"data", (getter)AEDesc_get_data, (setter)AEDesc_set_data, "The raw data in this AEDesc"},
|
|
{NULL, NULL, NULL, NULL},
|
|
};
|
|
|
|
|
|
#define AEDesc_compare NULL
|
|
|
|
#define AEDesc_repr NULL
|
|
|
|
#define AEDesc_hash NULL
|
|
#define AEDesc_tp_init 0
|
|
|
|
#define AEDesc_tp_alloc PyType_GenericAlloc
|
|
|
|
static PyObject *AEDesc_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
|
|
{
|
|
PyObject *_self;
|
|
AEDesc itself;
|
|
char *kw[] = {"itself", 0};
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, AEDesc_Convert, &itself)) return NULL;
|
|
if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
|
|
((AEDescObject *)_self)->ob_itself = itself;
|
|
return _self;
|
|
}
|
|
|
|
#define AEDesc_tp_free PyObject_Del
|
|
|
|
|
|
PyTypeObject AEDesc_Type = {
|
|
PyObject_HEAD_INIT(NULL)
|
|
0, /*ob_size*/
|
|
"_AE.AEDesc", /*tp_name*/
|
|
sizeof(AEDescObject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
(destructor) AEDesc_dealloc, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
(getattrfunc)0, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc) AEDesc_compare, /*tp_compare*/
|
|
(reprfunc) AEDesc_repr, /*tp_repr*/
|
|
(PyNumberMethods *)0, /* tp_as_number */
|
|
(PySequenceMethods *)0, /* tp_as_sequence */
|
|
(PyMappingMethods *)0, /* tp_as_mapping */
|
|
(hashfunc) AEDesc_hash, /*tp_hash*/
|
|
0, /*tp_call*/
|
|
0, /*tp_str*/
|
|
PyObject_GenericGetAttr, /*tp_getattro*/
|
|
PyObject_GenericSetAttr, /*tp_setattro */
|
|
0, /*tp_as_buffer*/
|
|
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
|
|
0, /*tp_doc*/
|
|
0, /*tp_traverse*/
|
|
0, /*tp_clear*/
|
|
0, /*tp_richcompare*/
|
|
0, /*tp_weaklistoffset*/
|
|
0, /*tp_iter*/
|
|
0, /*tp_iternext*/
|
|
AEDesc_methods, /* tp_methods */
|
|
0, /*tp_members*/
|
|
AEDesc_getsetlist, /*tp_getset*/
|
|
0, /*tp_base*/
|
|
0, /*tp_dict*/
|
|
0, /*tp_descr_get*/
|
|
0, /*tp_descr_set*/
|
|
0, /*tp_dictoffset*/
|
|
AEDesc_tp_init, /* tp_init */
|
|
AEDesc_tp_alloc, /* tp_alloc */
|
|
AEDesc_tp_new, /* tp_new */
|
|
AEDesc_tp_free, /* tp_free */
|
|
};
|
|
|
|
/* --------------------- End object type AEDesc --------------------- */
|
|
|
|
|
|
static PyObject *AE_AECoercePtr(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
DescType typeCode;
|
|
char *dataPtr__in__;
|
|
long dataPtr__len__;
|
|
int dataPtr__in_len__;
|
|
DescType toType;
|
|
AEDesc result;
|
|
#ifndef AECoercePtr
|
|
PyMac_PRECHECK(AECoercePtr);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&s#O&",
|
|
PyMac_GetOSType, &typeCode,
|
|
&dataPtr__in__, &dataPtr__in_len__,
|
|
PyMac_GetOSType, &toType))
|
|
return NULL;
|
|
dataPtr__len__ = dataPtr__in_len__;
|
|
_err = AECoercePtr(typeCode,
|
|
dataPtr__in__, dataPtr__len__,
|
|
toType,
|
|
&result);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
AEDesc_New, &result);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AECreateDesc(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
DescType typeCode;
|
|
char *dataPtr__in__;
|
|
long dataPtr__len__;
|
|
int dataPtr__in_len__;
|
|
AEDesc result;
|
|
#ifndef AECreateDesc
|
|
PyMac_PRECHECK(AECreateDesc);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&s#",
|
|
PyMac_GetOSType, &typeCode,
|
|
&dataPtr__in__, &dataPtr__in_len__))
|
|
return NULL;
|
|
dataPtr__len__ = dataPtr__in_len__;
|
|
_err = AECreateDesc(typeCode,
|
|
dataPtr__in__, dataPtr__len__,
|
|
&result);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
AEDesc_New, &result);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AECreateList(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
char *factoringPtr__in__;
|
|
long factoringPtr__len__;
|
|
int factoringPtr__in_len__;
|
|
Boolean isRecord;
|
|
AEDescList resultList;
|
|
#ifndef AECreateList
|
|
PyMac_PRECHECK(AECreateList);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "s#b",
|
|
&factoringPtr__in__, &factoringPtr__in_len__,
|
|
&isRecord))
|
|
return NULL;
|
|
factoringPtr__len__ = factoringPtr__in_len__;
|
|
_err = AECreateList(factoringPtr__in__, factoringPtr__len__,
|
|
isRecord,
|
|
&resultList);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
AEDesc_New, &resultList);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AECreateAppleEvent(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEEventClass theAEEventClass;
|
|
AEEventID theAEEventID;
|
|
AEAddressDesc target;
|
|
AEReturnID returnID;
|
|
AETransactionID transactionID;
|
|
AppleEvent result;
|
|
#ifndef AECreateAppleEvent
|
|
PyMac_PRECHECK(AECreateAppleEvent);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&O&hl",
|
|
PyMac_GetOSType, &theAEEventClass,
|
|
PyMac_GetOSType, &theAEEventID,
|
|
AEDesc_Convert, &target,
|
|
&returnID,
|
|
&transactionID))
|
|
return NULL;
|
|
_err = AECreateAppleEvent(theAEEventClass,
|
|
theAEEventID,
|
|
&target,
|
|
returnID,
|
|
transactionID,
|
|
&result);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
AEDesc_New, &result);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AEReplaceDescData(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
DescType typeCode;
|
|
char *dataPtr__in__;
|
|
long dataPtr__len__;
|
|
int dataPtr__in_len__;
|
|
AEDesc theAEDesc;
|
|
#ifndef AEReplaceDescData
|
|
PyMac_PRECHECK(AEReplaceDescData);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&s#",
|
|
PyMac_GetOSType, &typeCode,
|
|
&dataPtr__in__, &dataPtr__in_len__))
|
|
return NULL;
|
|
dataPtr__len__ = dataPtr__in_len__;
|
|
_err = AEReplaceDescData(typeCode,
|
|
dataPtr__in__, dataPtr__len__,
|
|
&theAEDesc);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
AEDesc_New, &theAEDesc);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AEProcessAppleEvent(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
EventRecord theEventRecord;
|
|
#ifndef AEProcessAppleEvent
|
|
PyMac_PRECHECK(AEProcessAppleEvent);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetEventRecord, &theEventRecord))
|
|
return NULL;
|
|
_err = AEProcessAppleEvent(&theEventRecord);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AEGetInteractionAllowed(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEInteractAllowed level;
|
|
#ifndef AEGetInteractionAllowed
|
|
PyMac_PRECHECK(AEGetInteractionAllowed);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = AEGetInteractionAllowed(&level);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("b",
|
|
level);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AESetInteractionAllowed(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEInteractAllowed level;
|
|
#ifndef AESetInteractionAllowed
|
|
PyMac_PRECHECK(AESetInteractionAllowed);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
&level))
|
|
return NULL;
|
|
_err = AESetInteractionAllowed(level);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AEInteractWithUser(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
long timeOutInTicks;
|
|
#ifndef AEInteractWithUser
|
|
PyMac_PRECHECK(AEInteractWithUser);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "l",
|
|
&timeOutInTicks))
|
|
return NULL;
|
|
_err = AEInteractWithUser(timeOutInTicks,
|
|
(NMRecPtr)0,
|
|
upp_AEIdleProc);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AEInstallEventHandler(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEEventClass theAEEventClass;
|
|
AEEventID theAEEventID;
|
|
AEEventHandlerUPP handler__proc__ = upp_GenericEventHandler;
|
|
PyObject *handler;
|
|
#ifndef AEInstallEventHandler
|
|
PyMac_PRECHECK(AEInstallEventHandler);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&O",
|
|
PyMac_GetOSType, &theAEEventClass,
|
|
PyMac_GetOSType, &theAEEventID,
|
|
&handler))
|
|
return NULL;
|
|
_err = AEInstallEventHandler(theAEEventClass,
|
|
theAEEventID,
|
|
handler__proc__, (SRefCon)handler,
|
|
0);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
Py_INCREF(handler); /* XXX leak, but needed */
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AERemoveEventHandler(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEEventClass theAEEventClass;
|
|
AEEventID theAEEventID;
|
|
#ifndef AERemoveEventHandler
|
|
PyMac_PRECHECK(AERemoveEventHandler);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
PyMac_GetOSType, &theAEEventClass,
|
|
PyMac_GetOSType, &theAEEventID))
|
|
return NULL;
|
|
_err = AERemoveEventHandler(theAEEventClass,
|
|
theAEEventID,
|
|
upp_GenericEventHandler,
|
|
0);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AEGetEventHandler(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEEventClass theAEEventClass;
|
|
AEEventID theAEEventID;
|
|
AEEventHandlerUPP handler__proc__ = upp_GenericEventHandler;
|
|
PyObject *handler;
|
|
#ifndef AEGetEventHandler
|
|
PyMac_PRECHECK(AEGetEventHandler);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
PyMac_GetOSType, &theAEEventClass,
|
|
PyMac_GetOSType, &theAEEventID))
|
|
return NULL;
|
|
_err = AEGetEventHandler(theAEEventClass,
|
|
theAEEventID,
|
|
&handler__proc__, (SRefCon *)&handler,
|
|
0);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O",
|
|
handler);
|
|
Py_INCREF(handler); /* XXX leak, but needed */
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AEInstallSpecialHandler(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEKeyword functionClass;
|
|
#ifndef AEInstallSpecialHandler
|
|
PyMac_PRECHECK(AEInstallSpecialHandler);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetOSType, &functionClass))
|
|
return NULL;
|
|
_err = AEInstallSpecialHandler(functionClass,
|
|
upp_GenericEventHandler,
|
|
0);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AERemoveSpecialHandler(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEKeyword functionClass;
|
|
#ifndef AERemoveSpecialHandler
|
|
PyMac_PRECHECK(AERemoveSpecialHandler);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetOSType, &functionClass))
|
|
return NULL;
|
|
_err = AERemoveSpecialHandler(functionClass,
|
|
upp_GenericEventHandler,
|
|
0);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AEManagerInfo(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEKeyword keyWord;
|
|
long result;
|
|
#ifndef AEManagerInfo
|
|
PyMac_PRECHECK(AEManagerInfo);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetOSType, &keyWord))
|
|
return NULL;
|
|
_err = AEManagerInfo(keyWord,
|
|
&result);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("l",
|
|
result);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AEObjectInit(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
#ifndef AEObjectInit
|
|
PyMac_PRECHECK(AEObjectInit);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = AEObjectInit();
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AEDisposeToken(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AEDesc theToken;
|
|
#ifndef AEDisposeToken
|
|
PyMac_PRECHECK(AEDisposeToken);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = AEDisposeToken(&theToken);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
AEDesc_New, &theToken);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *AE_AECallObjectAccessor(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
DescType desiredClass;
|
|
AEDesc containerToken;
|
|
DescType containerClass;
|
|
DescType keyForm;
|
|
AEDesc keyData;
|
|
AEDesc token;
|
|
#ifndef AECallObjectAccessor
|
|
PyMac_PRECHECK(AECallObjectAccessor);
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "O&O&O&O&O&",
|
|
PyMac_GetOSType, &desiredClass,
|
|
AEDesc_Convert, &containerToken,
|
|
PyMac_GetOSType, &containerClass,
|
|
PyMac_GetOSType, &keyForm,
|
|
AEDesc_Convert, &keyData))
|
|
return NULL;
|
|
_err = AECallObjectAccessor(desiredClass,
|
|
&containerToken,
|
|
containerClass,
|
|
keyForm,
|
|
&keyData,
|
|
&token);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
AEDesc_New, &token);
|
|
return _res;
|
|
}
|
|
|
|
static PyMethodDef AE_methods[] = {
|
|
{"AECoercePtr", (PyCFunction)AE_AECoercePtr, 1,
|
|
PyDoc_STR("(DescType typeCode, Buffer dataPtr, DescType toType) -> (AEDesc result)")},
|
|
{"AECreateDesc", (PyCFunction)AE_AECreateDesc, 1,
|
|
PyDoc_STR("(DescType typeCode, Buffer dataPtr) -> (AEDesc result)")},
|
|
{"AECreateList", (PyCFunction)AE_AECreateList, 1,
|
|
PyDoc_STR("(Buffer factoringPtr, Boolean isRecord) -> (AEDescList resultList)")},
|
|
{"AECreateAppleEvent", (PyCFunction)AE_AECreateAppleEvent, 1,
|
|
PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID, AEAddressDesc target, AEReturnID returnID, AETransactionID transactionID) -> (AppleEvent result)")},
|
|
{"AEReplaceDescData", (PyCFunction)AE_AEReplaceDescData, 1,
|
|
PyDoc_STR("(DescType typeCode, Buffer dataPtr) -> (AEDesc theAEDesc)")},
|
|
{"AEProcessAppleEvent", (PyCFunction)AE_AEProcessAppleEvent, 1,
|
|
PyDoc_STR("(EventRecord theEventRecord) -> None")},
|
|
{"AEGetInteractionAllowed", (PyCFunction)AE_AEGetInteractionAllowed, 1,
|
|
PyDoc_STR("() -> (AEInteractAllowed level)")},
|
|
{"AESetInteractionAllowed", (PyCFunction)AE_AESetInteractionAllowed, 1,
|
|
PyDoc_STR("(AEInteractAllowed level) -> None")},
|
|
{"AEInteractWithUser", (PyCFunction)AE_AEInteractWithUser, 1,
|
|
PyDoc_STR("(long timeOutInTicks) -> None")},
|
|
{"AEInstallEventHandler", (PyCFunction)AE_AEInstallEventHandler, 1,
|
|
PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID, EventHandler handler) -> None")},
|
|
{"AERemoveEventHandler", (PyCFunction)AE_AERemoveEventHandler, 1,
|
|
PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID) -> None")},
|
|
{"AEGetEventHandler", (PyCFunction)AE_AEGetEventHandler, 1,
|
|
PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID) -> (EventHandler handler)")},
|
|
{"AEInstallSpecialHandler", (PyCFunction)AE_AEInstallSpecialHandler, 1,
|
|
PyDoc_STR("(AEKeyword functionClass) -> None")},
|
|
{"AERemoveSpecialHandler", (PyCFunction)AE_AERemoveSpecialHandler, 1,
|
|
PyDoc_STR("(AEKeyword functionClass) -> None")},
|
|
{"AEManagerInfo", (PyCFunction)AE_AEManagerInfo, 1,
|
|
PyDoc_STR("(AEKeyword keyWord) -> (long result)")},
|
|
{"AEObjectInit", (PyCFunction)AE_AEObjectInit, 1,
|
|
PyDoc_STR("() -> None")},
|
|
{"AEDisposeToken", (PyCFunction)AE_AEDisposeToken, 1,
|
|
PyDoc_STR("() -> (AEDesc theToken)")},
|
|
{"AECallObjectAccessor", (PyCFunction)AE_AECallObjectAccessor, 1,
|
|
PyDoc_STR("(DescType desiredClass, AEDesc containerToken, DescType containerClass, DescType keyForm, AEDesc keyData) -> (AEDesc token)")},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
|
|
|
|
static pascal OSErr
|
|
GenericEventHandler(const AppleEvent *request, AppleEvent *reply, refcontype refcon)
|
|
{
|
|
PyObject *handler = (PyObject *)refcon;
|
|
AEDescObject *requestObject, *replyObject;
|
|
PyObject *args, *res;
|
|
if ((requestObject = (AEDescObject *)AEDesc_New((AppleEvent *)request)) == NULL) {
|
|
return -1;
|
|
}
|
|
if ((replyObject = (AEDescObject *)AEDesc_New(reply)) == NULL) {
|
|
Py_DECREF(requestObject);
|
|
return -1;
|
|
}
|
|
if ((args = Py_BuildValue("OO", requestObject, replyObject)) == NULL) {
|
|
Py_DECREF(requestObject);
|
|
Py_DECREF(replyObject);
|
|
return -1;
|
|
}
|
|
res = PyEval_CallObject(handler, args);
|
|
requestObject->ob_itself.descriptorType = 'null';
|
|
requestObject->ob_itself.dataHandle = NULL;
|
|
replyObject->ob_itself.descriptorType = 'null';
|
|
replyObject->ob_itself.dataHandle = NULL;
|
|
Py_DECREF(args);
|
|
if (res == NULL) {
|
|
PySys_WriteStderr("Exception in AE event handler function\n");
|
|
PyErr_Print();
|
|
return -1;
|
|
}
|
|
Py_DECREF(res);
|
|
return noErr;
|
|
}
|
|
|
|
PyObject *AEDesc_NewBorrowed(AEDesc *itself)
|
|
{
|
|
PyObject *it;
|
|
|
|
it = AEDesc_New(itself);
|
|
if (it)
|
|
((AEDescObject *)it)->ob_owned = 0;
|
|
return (PyObject *)it;
|
|
}
|
|
|
|
|
|
|
|
void init_AE(void)
|
|
{
|
|
PyObject *m;
|
|
PyObject *d;
|
|
|
|
upp_AEIdleProc = NewAEIdleUPP(AEIdleProc);
|
|
upp_GenericEventHandler = NewAEEventHandlerUPP(GenericEventHandler);
|
|
PyMac_INIT_TOOLBOX_OBJECT_NEW(AEDesc *, AEDesc_New);
|
|
PyMac_INIT_TOOLBOX_OBJECT_NEW(AEDesc *, AEDesc_NewBorrowed);
|
|
PyMac_INIT_TOOLBOX_OBJECT_CONVERT(AEDesc, AEDesc_Convert);
|
|
|
|
m = Py_InitModule("_AE", AE_methods);
|
|
d = PyModule_GetDict(m);
|
|
AE_Error = PyMac_GetOSErrException();
|
|
if (AE_Error == NULL ||
|
|
PyDict_SetItemString(d, "Error", AE_Error) != 0)
|
|
return;
|
|
AEDesc_Type.ob_type = &PyType_Type;
|
|
if (PyType_Ready(&AEDesc_Type) < 0) return;
|
|
Py_INCREF(&AEDesc_Type);
|
|
PyModule_AddObject(m, "AEDesc", (PyObject *)&AEDesc_Type);
|
|
/* Backward-compatible name */
|
|
Py_INCREF(&AEDesc_Type);
|
|
PyModule_AddObject(m, "AEDescType", (PyObject *)&AEDesc_Type);
|
|
}
|
|
|
|
/* ========================= End module _AE ========================= */
|
|
|