--- /dev/null
+
+/* =========================== Module _AE =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <AppleEvents.h>
+#include <AEObjects.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+extern PyObject *_AEDesc_New(AEDesc *);
+extern int _AEDesc_Convert(PyObject *, AEDesc *);
+
+#define AEDesc_New _AEDesc_New
+#define AEDesc_Convert _AEDesc_Convert
+#endif
+
+static pascal OSErr GenericEventHandler(); /* Forward */
+
+AEEventHandlerUPP upp_GenericEventHandler;
+
+static pascal Boolean AEIdleProc(EventRecord *theEvent, long *sleepTime, RgnHandle *mouseRgn)
+{
+ if ( PyOS_InterruptOccurred() )
+ return 1;
+ if ( PyMac_HandleEvent(theEvent) < 0 ) {
+ PySys_WriteStderr("Exception in user event handler during AE processing\n");
+ PyErr_Clear();
+ }
+ return 0;
+}
+
+AEIdleUPP upp_AEIdleProc;
+
+static PyObject *AE_Error;
+
+/* ----------------------- Object type AEDesc ----------------------- */
+
+PyTypeObject AEDesc_Type;
+
+#define AEDesc_Check(x) ((x)->ob_type == &AEDesc_Type)
+
+typedef struct AEDescObject {
+ PyObject_HEAD
+ AEDesc ob_itself;
+} AEDescObject;
+
+PyObject *AEDesc_New(AEDesc *itself)
+{
+ AEDescObject *it;
+ it = PyObject_NEW(AEDescObject, &AEDesc_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = *itself;
+ return (PyObject *)it;
+}
+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)
+{
+ AEDisposeDesc(&self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *AEDesc_AECoerceDesc(AEDescObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ DescType toType;
+ AEDesc result;
+ 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;
+ 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;
+ 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__;
+ 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;
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *AEDesc_AEPutDesc(AEDescObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long index;
+ AEDesc theAEDesc;
+ 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__;
+ 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;
+ 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;
+ 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;
+ 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__;
+ 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;
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *AEDesc_AEPutParamDesc(AEDescObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ AEDesc theAEDesc;
+ 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__;
+ 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;
+ 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;
+ 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;
+ 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__;
+ 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;
+ 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;
+ 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__;
+ 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;
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *AEDesc_AEPutAttributeDesc(AEDescObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ AEDesc theAEDesc;
+ 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;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *AEDesc_AEGetDescDataSize(AEDescObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Size _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = AEGetDescDataSize(&_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *AEDesc_AESend(AEDescObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AppleEvent reply;
+ AESendMode sendMode;
+ AESendPriority sendPriority;
+ long timeOutInTicks;
+ 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;
+ 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;
+ 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;
+ if (!PyArg_ParseTuple(_args, "O&O",
+ AEDesc_Convert, &reply,
+ &dispatcher))
+ return NULL;
+ _err = AEResumeTheCurrentEvent(&_self->ob_itself,
+ &reply,
+ dispatcher__proc__, (long)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;
+ 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;
+ 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;
+ 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 PyMethodDef AEDesc_methods[] = {
+ {"AECoerceDesc", (PyCFunction)AEDesc_AECoerceDesc, 1,
+ "(DescType toType) -> (AEDesc result)"},
+ {"AEDuplicateDesc", (PyCFunction)AEDesc_AEDuplicateDesc, 1,
+ "() -> (AEDesc result)"},
+ {"AECountItems", (PyCFunction)AEDesc_AECountItems, 1,
+ "() -> (long theCount)"},
+ {"AEPutPtr", (PyCFunction)AEDesc_AEPutPtr, 1,
+ "(long index, DescType typeCode, Buffer dataPtr) -> None"},
+ {"AEPutDesc", (PyCFunction)AEDesc_AEPutDesc, 1,
+ "(long index, AEDesc theAEDesc) -> None"},
+ {"AEGetNthPtr", (PyCFunction)AEDesc_AEGetNthPtr, 1,
+ "(long index, DescType desiredType, Buffer dataPtr) -> (AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr)"},
+ {"AEGetNthDesc", (PyCFunction)AEDesc_AEGetNthDesc, 1,
+ "(long index, DescType desiredType) -> (AEKeyword theAEKeyword, AEDesc result)"},
+ {"AESizeOfNthItem", (PyCFunction)AEDesc_AESizeOfNthItem, 1,
+ "(long index) -> (DescType typeCode, Size dataSize)"},
+ {"AEDeleteItem", (PyCFunction)AEDesc_AEDeleteItem, 1,
+ "(long index) -> None"},
+ {"AEPutParamPtr", (PyCFunction)AEDesc_AEPutParamPtr, 1,
+ "(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None"},
+ {"AEPutParamDesc", (PyCFunction)AEDesc_AEPutParamDesc, 1,
+ "(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None"},
+ {"AEGetParamPtr", (PyCFunction)AEDesc_AEGetParamPtr, 1,
+ "(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)"},
+ {"AEGetParamDesc", (PyCFunction)AEDesc_AEGetParamDesc, 1,
+ "(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)"},
+ {"AESizeOfParam", (PyCFunction)AEDesc_AESizeOfParam, 1,
+ "(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)"},
+ {"AEDeleteParam", (PyCFunction)AEDesc_AEDeleteParam, 1,
+ "(AEKeyword theAEKeyword) -> None"},
+ {"AEGetAttributePtr", (PyCFunction)AEDesc_AEGetAttributePtr, 1,
+ "(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)"},
+ {"AEGetAttributeDesc", (PyCFunction)AEDesc_AEGetAttributeDesc, 1,
+ "(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)"},
+ {"AESizeOfAttribute", (PyCFunction)AEDesc_AESizeOfAttribute, 1,
+ "(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)"},
+ {"AEPutAttributePtr", (PyCFunction)AEDesc_AEPutAttributePtr, 1,
+ "(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None"},
+ {"AEPutAttributeDesc", (PyCFunction)AEDesc_AEPutAttributeDesc, 1,
+ "(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"AEGetDescDataSize", (PyCFunction)AEDesc_AEGetDescDataSize, 1,
+ "() -> (Size _rv)"},
+#endif
+ {"AESend", (PyCFunction)AEDesc_AESend, 1,
+ "(AESendMode sendMode, AESendPriority sendPriority, long timeOutInTicks) -> (AppleEvent reply)"},
+ {"AEResetTimer", (PyCFunction)AEDesc_AEResetTimer, 1,
+ "() -> None"},
+ {"AESuspendTheCurrentEvent", (PyCFunction)AEDesc_AESuspendTheCurrentEvent, 1,
+ "() -> None"},
+ {"AEResumeTheCurrentEvent", (PyCFunction)AEDesc_AEResumeTheCurrentEvent, 1,
+ "(AppleEvent reply, EventHandler dispatcher) -> None"},
+ {"AEGetTheCurrentEvent", (PyCFunction)AEDesc_AEGetTheCurrentEvent, 1,
+ "() -> None"},
+ {"AESetTheCurrentEvent", (PyCFunction)AEDesc_AESetTheCurrentEvent, 1,
+ "() -> None"},
+ {"AEResolve", (PyCFunction)AEDesc_AEResolve, 1,
+ "(short callbackFlags) -> (AEDesc theToken)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain AEDesc_chain = { AEDesc_methods, NULL };
+
+static PyObject *AEDesc_getattr(AEDescObject *self, char *name)
+{
+
+ if (strcmp(name, "type") == 0)
+ return PyMac_BuildOSType(self->ob_itself.descriptorType);
+ if (strcmp(name, "data") == 0) {
+ PyObject *res;
+#if !TARGET_API_MAC_CARBON
+ char state;
+ state = HGetState(self->ob_itself.dataHandle);
+ HLock(self->ob_itself.dataHandle);
+ res = PyString_FromStringAndSize(
+ *self->ob_itself.dataHandle,
+ GetHandleSize(self->ob_itself.dataHandle));
+ HUnlock(self->ob_itself.dataHandle);
+ HSetState(self->ob_itself.dataHandle, state);
+#else
+ 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);
+#endif
+ return res;
+ }
+ if (strcmp(name, "__members__") == 0)
+ return Py_BuildValue("[ss]", "data", "type");
+
+ return Py_FindMethodInChain(&AEDesc_chain, (PyObject *)self, name);
+}
+
+#define AEDesc_setattr NULL
+
+#define AEDesc_compare NULL
+
+#define AEDesc_repr NULL
+
+#define AEDesc_hash NULL
+
+PyTypeObject AEDesc_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "AEDesc", /*tp_name*/
+ sizeof(AEDescObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) AEDesc_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) AEDesc_getattr, /*tp_getattr*/
+ (setattrfunc) AEDesc_setattr, /*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*/
+};
+
+/* --------------------- 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;
+ 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);
+ dataPtr__error__: ;
+ 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;
+ 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);
+ dataPtr__error__: ;
+ 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;
+ 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);
+ factoringPtr__error__: ;
+ 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;
+ 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;
+}
+
+#if TARGET_API_MAC_CARBON
+
+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;
+ 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);
+ dataPtr__error__: ;
+ return _res;
+}
+#endif
+
+static PyObject *AE_AEProcessAppleEvent(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ EventRecord theEventRecord;
+ 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;
+ 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;
+ 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;
+ 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;
+ if (!PyArg_ParseTuple(_args, "O&O&O",
+ PyMac_GetOSType, &theAEEventClass,
+ PyMac_GetOSType, &theAEEventID,
+ &handler))
+ return NULL;
+ _err = AEInstallEventHandler(theAEEventClass,
+ theAEEventID,
+ handler__proc__, (long)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;
+ 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;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &theAEEventClass,
+ PyMac_GetOSType, &theAEEventID))
+ return NULL;
+ _err = AEGetEventHandler(theAEEventClass,
+ theAEEventID,
+ &handler__proc__, (long *)&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;
+ 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;
+ 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;
+ 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;
+ 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;
+ 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;
+ 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,
+ "(DescType typeCode, Buffer dataPtr, DescType toType) -> (AEDesc result)"},
+ {"AECreateDesc", (PyCFunction)AE_AECreateDesc, 1,
+ "(DescType typeCode, Buffer dataPtr) -> (AEDesc result)"},
+ {"AECreateList", (PyCFunction)AE_AECreateList, 1,
+ "(Buffer factoringPtr, Boolean isRecord) -> (AEDescList resultList)"},
+ {"AECreateAppleEvent", (PyCFunction)AE_AECreateAppleEvent, 1,
+ "(AEEventClass theAEEventClass, AEEventID theAEEventID, AEAddressDesc target, AEReturnID returnID, AETransactionID transactionID) -> (AppleEvent result)"},
+
+#if TARGET_API_MAC_CARBON
+ {"AEReplaceDescData", (PyCFunction)AE_AEReplaceDescData, 1,
+ "(DescType typeCode, Buffer dataPtr) -> (AEDesc theAEDesc)"},
+#endif
+ {"AEProcessAppleEvent", (PyCFunction)AE_AEProcessAppleEvent, 1,
+ "(EventRecord theEventRecord) -> None"},
+ {"AEGetInteractionAllowed", (PyCFunction)AE_AEGetInteractionAllowed, 1,
+ "() -> (AEInteractAllowed level)"},
+ {"AESetInteractionAllowed", (PyCFunction)AE_AESetInteractionAllowed, 1,
+ "(AEInteractAllowed level) -> None"},
+ {"AEInteractWithUser", (PyCFunction)AE_AEInteractWithUser, 1,
+ "(long timeOutInTicks) -> None"},
+ {"AEInstallEventHandler", (PyCFunction)AE_AEInstallEventHandler, 1,
+ "(AEEventClass theAEEventClass, AEEventID theAEEventID, EventHandler handler) -> None"},
+ {"AERemoveEventHandler", (PyCFunction)AE_AERemoveEventHandler, 1,
+ "(AEEventClass theAEEventClass, AEEventID theAEEventID) -> None"},
+ {"AEGetEventHandler", (PyCFunction)AE_AEGetEventHandler, 1,
+ "(AEEventClass theAEEventClass, AEEventID theAEEventID) -> (EventHandler handler)"},
+ {"AEInstallSpecialHandler", (PyCFunction)AE_AEInstallSpecialHandler, 1,
+ "(AEKeyword functionClass) -> None"},
+ {"AERemoveSpecialHandler", (PyCFunction)AE_AERemoveSpecialHandler, 1,
+ "(AEKeyword functionClass) -> None"},
+ {"AEManagerInfo", (PyCFunction)AE_AEManagerInfo, 1,
+ "(AEKeyword keyWord) -> (long result)"},
+ {"AEObjectInit", (PyCFunction)AE_AEObjectInit, 1,
+ "() -> None"},
+ {"AEDisposeToken", (PyCFunction)AE_AEDisposeToken, 1,
+ "() -> (AEDesc theToken)"},
+ {"AECallObjectAccessor", (PyCFunction)AE_AECallObjectAccessor, 1,
+ "(DescType desiredClass, AEDesc containerToken, DescType containerClass, DescType keyForm, AEDesc keyData) -> (AEDesc token)"},
+ {NULL, NULL, 0}
+};
+
+
+
+#if UNIVERSAL_INTERFACES_VERSION >= 0x0340
+typedef long refcontype;
+#else
+typedef unsigned long refcontype;
+#endif
+
+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)
+ return -1;
+ Py_DECREF(res);
+ return noErr;
+}
+
+
+void init_AE(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ upp_AEIdleProc = NewAEIdleUPP(AEIdleProc);
+#if UNIVERSAL_INTERFACES_VERSION >= 0x03400
+ upp_GenericEventHandler = NewAEEventHandlerUPP(&GenericEventHandler);
+#else
+ upp_GenericEventHandler = NewAEEventHandlerUPP(GenericEventHandler);
+#endif
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(AEDesc *, AEDesc_New);
+ 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;
+ Py_INCREF(&AEDesc_Type);
+ if (PyDict_SetItemString(d, "AEDescType", (PyObject *)&AEDesc_Type) != 0)
+ Py_FatalError("can't initialize AEDescType");
+}
+
+/* ========================= End module _AE ========================= */
+
--- /dev/null
+
+/* ========================== Module _App =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Appearance.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+
+static PyObject *App_Error;
+
+static PyObject *App_RegisterAppearanceClient(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = RegisterAppearanceClient();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_UnregisterAppearanceClient(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = UnregisterAppearanceClient();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_SetThemePen(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeBrush inBrush;
+ SInt16 inDepth;
+ Boolean inIsColorDevice;
+ if (!PyArg_ParseTuple(_args, "hhb",
+ &inBrush,
+ &inDepth,
+ &inIsColorDevice))
+ return NULL;
+ _err = SetThemePen(inBrush,
+ inDepth,
+ inIsColorDevice);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_SetThemeBackground(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeBrush inBrush;
+ SInt16 inDepth;
+ Boolean inIsColorDevice;
+ if (!PyArg_ParseTuple(_args, "hhb",
+ &inBrush,
+ &inDepth,
+ &inIsColorDevice))
+ return NULL;
+ _err = SetThemeBackground(inBrush,
+ inDepth,
+ inIsColorDevice);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_SetThemeTextColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeTextColor inColor;
+ SInt16 inDepth;
+ Boolean inIsColorDevice;
+ if (!PyArg_ParseTuple(_args, "hhb",
+ &inColor,
+ &inDepth,
+ &inIsColorDevice))
+ return NULL;
+ _err = SetThemeTextColor(inColor,
+ inDepth,
+ inIsColorDevice);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_SetThemeWindowBackground(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowPtr inWindow;
+ ThemeBrush inBrush;
+ Boolean inUpdate;
+ if (!PyArg_ParseTuple(_args, "O&hb",
+ WinObj_Convert, &inWindow,
+ &inBrush,
+ &inUpdate))
+ return NULL;
+ _err = SetThemeWindowBackground(inWindow,
+ inBrush,
+ inUpdate);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeWindowHeader(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inRect;
+ ThemeDrawState inState;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetRect, &inRect,
+ &inState))
+ return NULL;
+ _err = DrawThemeWindowHeader(&inRect,
+ inState);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeWindowListViewHeader(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inRect;
+ ThemeDrawState inState;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetRect, &inRect,
+ &inState))
+ return NULL;
+ _err = DrawThemeWindowListViewHeader(&inRect,
+ inState);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemePlacard(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inRect;
+ ThemeDrawState inState;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetRect, &inRect,
+ &inState))
+ return NULL;
+ _err = DrawThemePlacard(&inRect,
+ inState);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeEditTextFrame(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inRect;
+ ThemeDrawState inState;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetRect, &inRect,
+ &inState))
+ return NULL;
+ _err = DrawThemeEditTextFrame(&inRect,
+ inState);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeListBoxFrame(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inRect;
+ ThemeDrawState inState;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetRect, &inRect,
+ &inState))
+ return NULL;
+ _err = DrawThemeListBoxFrame(&inRect,
+ inState);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeFocusRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inRect;
+ Boolean inHasFocus;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ PyMac_GetRect, &inRect,
+ &inHasFocus))
+ return NULL;
+ _err = DrawThemeFocusRect(&inRect,
+ inHasFocus);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemePrimaryGroup(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inRect;
+ ThemeDrawState inState;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetRect, &inRect,
+ &inState))
+ return NULL;
+ _err = DrawThemePrimaryGroup(&inRect,
+ inState);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeSecondaryGroup(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inRect;
+ ThemeDrawState inState;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetRect, &inRect,
+ &inState))
+ return NULL;
+ _err = DrawThemeSecondaryGroup(&inRect,
+ inState);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeSeparator(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inRect;
+ ThemeDrawState inState;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetRect, &inRect,
+ &inState))
+ return NULL;
+ _err = DrawThemeSeparator(&inRect,
+ inState);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeModelessDialogFrame(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inRect;
+ ThemeDrawState inState;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetRect, &inRect,
+ &inState))
+ return NULL;
+ _err = DrawThemeModelessDialogFrame(&inRect,
+ inState);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeGenericWell(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inRect;
+ ThemeDrawState inState;
+ Boolean inFillCenter;
+ if (!PyArg_ParseTuple(_args, "O&lb",
+ PyMac_GetRect, &inRect,
+ &inState,
+ &inFillCenter))
+ return NULL;
+ _err = DrawThemeGenericWell(&inRect,
+ inState,
+ inFillCenter);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeFocusRegion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Boolean inHasFocus;
+ if (!PyArg_ParseTuple(_args, "b",
+ &inHasFocus))
+ return NULL;
+ _err = DrawThemeFocusRegion((RgnHandle)0,
+ inHasFocus);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_IsThemeInColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ SInt16 inDepth;
+ Boolean inIsColorDevice;
+ if (!PyArg_ParseTuple(_args, "hb",
+ &inDepth,
+ &inIsColorDevice))
+ return NULL;
+ _rv = IsThemeInColor(inDepth,
+ inIsColorDevice);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *App_GetThemeAccentColors(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ CTabHandle outColors;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetThemeAccentColors(&outColors);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, outColors);
+ return _res;
+}
+
+static PyObject *App_DrawThemeMenuBarBackground(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inBounds;
+ ThemeMenuBarState inState;
+ UInt32 inAttributes;
+ if (!PyArg_ParseTuple(_args, "O&Hl",
+ PyMac_GetRect, &inBounds,
+ &inState,
+ &inAttributes))
+ return NULL;
+ _err = DrawThemeMenuBarBackground(&inBounds,
+ inState,
+ inAttributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_GetThemeMenuBarHeight(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ SInt16 outHeight;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetThemeMenuBarHeight(&outHeight);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ outHeight);
+ return _res;
+}
+
+static PyObject *App_DrawThemeMenuBackground(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inMenuRect;
+ ThemeMenuType inMenuType;
+ if (!PyArg_ParseTuple(_args, "O&H",
+ PyMac_GetRect, &inMenuRect,
+ &inMenuType))
+ return NULL;
+ _err = DrawThemeMenuBackground(&inMenuRect,
+ inMenuType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_GetThemeMenuBackgroundRegion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inMenuRect;
+ ThemeMenuType menuType;
+ if (!PyArg_ParseTuple(_args, "O&H",
+ PyMac_GetRect, &inMenuRect,
+ &menuType))
+ return NULL;
+ _err = GetThemeMenuBackgroundRegion(&inMenuRect,
+ menuType,
+ (RgnHandle)0);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeMenuSeparator(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inItemRect;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &inItemRect))
+ return NULL;
+ _err = DrawThemeMenuSeparator(&inItemRect);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_GetThemeMenuSeparatorHeight(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ SInt16 outHeight;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetThemeMenuSeparatorHeight(&outHeight);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ outHeight);
+ return _res;
+}
+
+static PyObject *App_GetThemeMenuItemExtra(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeMenuItemType inItemType;
+ SInt16 outHeight;
+ SInt16 outWidth;
+ if (!PyArg_ParseTuple(_args, "H",
+ &inItemType))
+ return NULL;
+ _err = GetThemeMenuItemExtra(inItemType,
+ &outHeight,
+ &outWidth);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("hh",
+ outHeight,
+ outWidth);
+ return _res;
+}
+
+static PyObject *App_GetThemeMenuTitleExtra(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ SInt16 outWidth;
+ Boolean inIsSquished;
+ if (!PyArg_ParseTuple(_args, "b",
+ &inIsSquished))
+ return NULL;
+ _err = GetThemeMenuTitleExtra(&outWidth,
+ inIsSquished);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ outWidth);
+ return _res;
+}
+
+static PyObject *App_DrawThemeTabPane(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inRect;
+ ThemeDrawState inState;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetRect, &inRect,
+ &inState))
+ return NULL;
+ _err = DrawThemeTabPane(&inRect,
+ inState);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_GetThemeTabRegion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inRect;
+ ThemeTabStyle inStyle;
+ ThemeTabDirection inDirection;
+ if (!PyArg_ParseTuple(_args, "O&HH",
+ PyMac_GetRect, &inRect,
+ &inStyle,
+ &inDirection))
+ return NULL;
+ _err = GetThemeTabRegion(&inRect,
+ inStyle,
+ inDirection,
+ (RgnHandle)0);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_SetThemeCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeCursor inCursor;
+ if (!PyArg_ParseTuple(_args, "l",
+ &inCursor))
+ return NULL;
+ _err = SetThemeCursor(inCursor);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_SetAnimatedThemeCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeCursor inCursor;
+ UInt32 inAnimationStep;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &inCursor,
+ &inAnimationStep))
+ return NULL;
+ _err = SetAnimatedThemeCursor(inCursor,
+ inAnimationStep);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_GetThemeScrollBarThumbStyle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeScrollBarThumbStyle outStyle;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetThemeScrollBarThumbStyle(&outStyle);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("H",
+ outStyle);
+ return _res;
+}
+
+static PyObject *App_GetThemeScrollBarArrowStyle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeScrollBarArrowStyle outStyle;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetThemeScrollBarArrowStyle(&outStyle);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("H",
+ outStyle);
+ return _res;
+}
+
+static PyObject *App_GetThemeCheckBoxStyle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeCheckBoxStyle outStyle;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetThemeCheckBoxStyle(&outStyle);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("H",
+ outStyle);
+ return _res;
+}
+
+static PyObject *App_UseThemeFont(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeFontID inFontID;
+ ScriptCode inScript;
+ if (!PyArg_ParseTuple(_args, "Hh",
+ &inFontID,
+ &inScript))
+ return NULL;
+ _err = UseThemeFont(inFontID,
+ inScript);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeScrollBarArrows(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect bounds;
+ ThemeTrackEnableState enableState;
+ ThemeTrackPressState pressState;
+ Boolean isHoriz;
+ Rect trackBounds;
+ if (!PyArg_ParseTuple(_args, "O&bbb",
+ PyMac_GetRect, &bounds,
+ &enableState,
+ &pressState,
+ &isHoriz))
+ return NULL;
+ _err = DrawThemeScrollBarArrows(&bounds,
+ enableState,
+ pressState,
+ isHoriz,
+ &trackBounds);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &trackBounds);
+ return _res;
+}
+
+static PyObject *App_GetThemeScrollBarTrackRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect bounds;
+ ThemeTrackEnableState enableState;
+ ThemeTrackPressState pressState;
+ Boolean isHoriz;
+ Rect trackBounds;
+ if (!PyArg_ParseTuple(_args, "O&bbb",
+ PyMac_GetRect, &bounds,
+ &enableState,
+ &pressState,
+ &isHoriz))
+ return NULL;
+ _err = GetThemeScrollBarTrackRect(&bounds,
+ enableState,
+ pressState,
+ isHoriz,
+ &trackBounds);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &trackBounds);
+ return _res;
+}
+
+static PyObject *App_HitTestThemeScrollBarArrows(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Rect scrollBarBounds;
+ ThemeTrackEnableState enableState;
+ ThemeTrackPressState pressState;
+ Boolean isHoriz;
+ Point ptHit;
+ Rect trackBounds;
+ ControlPartCode partcode;
+ if (!PyArg_ParseTuple(_args, "O&bbbO&",
+ PyMac_GetRect, &scrollBarBounds,
+ &enableState,
+ &pressState,
+ &isHoriz,
+ PyMac_GetPoint, &ptHit))
+ return NULL;
+ _rv = HitTestThemeScrollBarArrows(&scrollBarBounds,
+ enableState,
+ pressState,
+ isHoriz,
+ ptHit,
+ &trackBounds,
+ &partcode);
+ _res = Py_BuildValue("bO&h",
+ _rv,
+ PyMac_BuildRect, &trackBounds,
+ partcode);
+ return _res;
+}
+
+static PyObject *App_DrawThemeScrollBarDelimiters(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeWindowType flavor;
+ Rect inContRect;
+ ThemeDrawState state;
+ ThemeWindowAttributes attributes;
+ if (!PyArg_ParseTuple(_args, "HO&ll",
+ &flavor,
+ PyMac_GetRect, &inContRect,
+ &state,
+ &attributes))
+ return NULL;
+ _err = DrawThemeScrollBarDelimiters(flavor,
+ &inContRect,
+ state,
+ attributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_PlayThemeSound(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeSoundKind kind;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &kind))
+ return NULL;
+ _err = PlayThemeSound(kind);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_BeginThemeDragSound(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeDragSoundKind kind;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &kind))
+ return NULL;
+ _err = BeginThemeDragSound(kind);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_EndThemeDragSound(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = EndThemeDragSound();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeTickMark(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect bounds;
+ ThemeDrawState state;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetRect, &bounds,
+ &state))
+ return NULL;
+ _err = DrawThemeTickMark(&bounds,
+ state);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeStandaloneGrowBox(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Point origin;
+ ThemeGrowDirection growDirection;
+ Boolean isSmall;
+ ThemeDrawState state;
+ if (!PyArg_ParseTuple(_args, "O&Hbl",
+ PyMac_GetPoint, &origin,
+ &growDirection,
+ &isSmall,
+ &state))
+ return NULL;
+ _err = DrawThemeStandaloneGrowBox(origin,
+ growDirection,
+ isSmall,
+ state);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_DrawThemeStandaloneNoGrowBox(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Point origin;
+ ThemeGrowDirection growDirection;
+ Boolean isSmall;
+ ThemeDrawState state;
+ if (!PyArg_ParseTuple(_args, "O&Hbl",
+ PyMac_GetPoint, &origin,
+ &growDirection,
+ &isSmall,
+ &state))
+ return NULL;
+ _err = DrawThemeStandaloneNoGrowBox(origin,
+ growDirection,
+ isSmall,
+ state);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_GetThemeStandaloneGrowBoxBounds(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Point origin;
+ ThemeGrowDirection growDirection;
+ Boolean isSmall;
+ Rect bounds;
+ if (!PyArg_ParseTuple(_args, "O&Hb",
+ PyMac_GetPoint, &origin,
+ &growDirection,
+ &isSmall))
+ return NULL;
+ _err = GetThemeStandaloneGrowBoxBounds(origin,
+ growDirection,
+ isSmall,
+ &bounds);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &bounds);
+ return _res;
+}
+
+static PyObject *App_NormalizeThemeDrawingState(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = NormalizeThemeDrawingState();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_ApplyThemeBackground(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeBackgroundKind inKind;
+ Rect bounds;
+ ThemeDrawState inState;
+ SInt16 inDepth;
+ Boolean inColorDev;
+ if (!PyArg_ParseTuple(_args, "lO&lhb",
+ &inKind,
+ PyMac_GetRect, &bounds,
+ &inState,
+ &inDepth,
+ &inColorDev))
+ return NULL;
+ _err = ApplyThemeBackground(inKind,
+ &bounds,
+ inState,
+ inDepth,
+ inColorDev);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_SetThemeTextColorForWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowPtr window;
+ Boolean isActive;
+ SInt16 depth;
+ Boolean isColorDev;
+ if (!PyArg_ParseTuple(_args, "O&bhb",
+ WinObj_Convert, &window,
+ &isActive,
+ &depth,
+ &isColorDev))
+ return NULL;
+ _err = SetThemeTextColorForWindow(window,
+ isActive,
+ depth,
+ isColorDev);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *App_IsValidAppearanceFileType(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ OSType fileType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &fileType))
+ return NULL;
+ _rv = IsValidAppearanceFileType(fileType);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *App_GetThemeBrushAsColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeBrush inBrush;
+ SInt16 inDepth;
+ Boolean inColorDev;
+ RGBColor outColor;
+ if (!PyArg_ParseTuple(_args, "hhb",
+ &inBrush,
+ &inDepth,
+ &inColorDev))
+ return NULL;
+ _err = GetThemeBrushAsColor(inBrush,
+ inDepth,
+ inColorDev,
+ &outColor);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &outColor);
+ return _res;
+}
+
+static PyObject *App_GetThemeTextColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeTextColor inColor;
+ SInt16 inDepth;
+ Boolean inColorDev;
+ RGBColor outColor;
+ if (!PyArg_ParseTuple(_args, "hhb",
+ &inColor,
+ &inDepth,
+ &inColorDev))
+ return NULL;
+ _err = GetThemeTextColor(inColor,
+ inDepth,
+ inColorDev,
+ &outColor);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &outColor);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *App_GetThemeMetric(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeMetric inMetric;
+ SInt32 outMetric;
+ if (!PyArg_ParseTuple(_args, "l",
+ &inMetric))
+ return NULL;
+ _err = GetThemeMetric(inMetric,
+ &outMetric);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outMetric);
+ return _res;
+}
+#endif
+
+static PyMethodDef App_methods[] = {
+ {"RegisterAppearanceClient", (PyCFunction)App_RegisterAppearanceClient, 1,
+ "() -> None"},
+ {"UnregisterAppearanceClient", (PyCFunction)App_UnregisterAppearanceClient, 1,
+ "() -> None"},
+ {"SetThemePen", (PyCFunction)App_SetThemePen, 1,
+ "(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None"},
+ {"SetThemeBackground", (PyCFunction)App_SetThemeBackground, 1,
+ "(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None"},
+ {"SetThemeTextColor", (PyCFunction)App_SetThemeTextColor, 1,
+ "(ThemeTextColor inColor, SInt16 inDepth, Boolean inIsColorDevice) -> None"},
+ {"SetThemeWindowBackground", (PyCFunction)App_SetThemeWindowBackground, 1,
+ "(WindowPtr inWindow, ThemeBrush inBrush, Boolean inUpdate) -> None"},
+ {"DrawThemeWindowHeader", (PyCFunction)App_DrawThemeWindowHeader, 1,
+ "(Rect inRect, ThemeDrawState inState) -> None"},
+ {"DrawThemeWindowListViewHeader", (PyCFunction)App_DrawThemeWindowListViewHeader, 1,
+ "(Rect inRect, ThemeDrawState inState) -> None"},
+ {"DrawThemePlacard", (PyCFunction)App_DrawThemePlacard, 1,
+ "(Rect inRect, ThemeDrawState inState) -> None"},
+ {"DrawThemeEditTextFrame", (PyCFunction)App_DrawThemeEditTextFrame, 1,
+ "(Rect inRect, ThemeDrawState inState) -> None"},
+ {"DrawThemeListBoxFrame", (PyCFunction)App_DrawThemeListBoxFrame, 1,
+ "(Rect inRect, ThemeDrawState inState) -> None"},
+ {"DrawThemeFocusRect", (PyCFunction)App_DrawThemeFocusRect, 1,
+ "(Rect inRect, Boolean inHasFocus) -> None"},
+ {"DrawThemePrimaryGroup", (PyCFunction)App_DrawThemePrimaryGroup, 1,
+ "(Rect inRect, ThemeDrawState inState) -> None"},
+ {"DrawThemeSecondaryGroup", (PyCFunction)App_DrawThemeSecondaryGroup, 1,
+ "(Rect inRect, ThemeDrawState inState) -> None"},
+ {"DrawThemeSeparator", (PyCFunction)App_DrawThemeSeparator, 1,
+ "(Rect inRect, ThemeDrawState inState) -> None"},
+ {"DrawThemeModelessDialogFrame", (PyCFunction)App_DrawThemeModelessDialogFrame, 1,
+ "(Rect inRect, ThemeDrawState inState) -> None"},
+ {"DrawThemeGenericWell", (PyCFunction)App_DrawThemeGenericWell, 1,
+ "(Rect inRect, ThemeDrawState inState, Boolean inFillCenter) -> None"},
+ {"DrawThemeFocusRegion", (PyCFunction)App_DrawThemeFocusRegion, 1,
+ "(Boolean inHasFocus) -> None"},
+ {"IsThemeInColor", (PyCFunction)App_IsThemeInColor, 1,
+ "(SInt16 inDepth, Boolean inIsColorDevice) -> (Boolean _rv)"},
+ {"GetThemeAccentColors", (PyCFunction)App_GetThemeAccentColors, 1,
+ "() -> (CTabHandle outColors)"},
+ {"DrawThemeMenuBarBackground", (PyCFunction)App_DrawThemeMenuBarBackground, 1,
+ "(Rect inBounds, ThemeMenuBarState inState, UInt32 inAttributes) -> None"},
+ {"GetThemeMenuBarHeight", (PyCFunction)App_GetThemeMenuBarHeight, 1,
+ "() -> (SInt16 outHeight)"},
+ {"DrawThemeMenuBackground", (PyCFunction)App_DrawThemeMenuBackground, 1,
+ "(Rect inMenuRect, ThemeMenuType inMenuType) -> None"},
+ {"GetThemeMenuBackgroundRegion", (PyCFunction)App_GetThemeMenuBackgroundRegion, 1,
+ "(Rect inMenuRect, ThemeMenuType menuType) -> None"},
+ {"DrawThemeMenuSeparator", (PyCFunction)App_DrawThemeMenuSeparator, 1,
+ "(Rect inItemRect) -> None"},
+ {"GetThemeMenuSeparatorHeight", (PyCFunction)App_GetThemeMenuSeparatorHeight, 1,
+ "() -> (SInt16 outHeight)"},
+ {"GetThemeMenuItemExtra", (PyCFunction)App_GetThemeMenuItemExtra, 1,
+ "(ThemeMenuItemType inItemType) -> (SInt16 outHeight, SInt16 outWidth)"},
+ {"GetThemeMenuTitleExtra", (PyCFunction)App_GetThemeMenuTitleExtra, 1,
+ "(Boolean inIsSquished) -> (SInt16 outWidth)"},
+ {"DrawThemeTabPane", (PyCFunction)App_DrawThemeTabPane, 1,
+ "(Rect inRect, ThemeDrawState inState) -> None"},
+ {"GetThemeTabRegion", (PyCFunction)App_GetThemeTabRegion, 1,
+ "(Rect inRect, ThemeTabStyle inStyle, ThemeTabDirection inDirection) -> None"},
+ {"SetThemeCursor", (PyCFunction)App_SetThemeCursor, 1,
+ "(ThemeCursor inCursor) -> None"},
+ {"SetAnimatedThemeCursor", (PyCFunction)App_SetAnimatedThemeCursor, 1,
+ "(ThemeCursor inCursor, UInt32 inAnimationStep) -> None"},
+ {"GetThemeScrollBarThumbStyle", (PyCFunction)App_GetThemeScrollBarThumbStyle, 1,
+ "() -> (ThemeScrollBarThumbStyle outStyle)"},
+ {"GetThemeScrollBarArrowStyle", (PyCFunction)App_GetThemeScrollBarArrowStyle, 1,
+ "() -> (ThemeScrollBarArrowStyle outStyle)"},
+ {"GetThemeCheckBoxStyle", (PyCFunction)App_GetThemeCheckBoxStyle, 1,
+ "() -> (ThemeCheckBoxStyle outStyle)"},
+ {"UseThemeFont", (PyCFunction)App_UseThemeFont, 1,
+ "(ThemeFontID inFontID, ScriptCode inScript) -> None"},
+ {"DrawThemeScrollBarArrows", (PyCFunction)App_DrawThemeScrollBarArrows, 1,
+ "(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)"},
+ {"GetThemeScrollBarTrackRect", (PyCFunction)App_GetThemeScrollBarTrackRect, 1,
+ "(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)"},
+ {"HitTestThemeScrollBarArrows", (PyCFunction)App_HitTestThemeScrollBarArrows, 1,
+ "(Rect scrollBarBounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz, Point ptHit) -> (Boolean _rv, Rect trackBounds, ControlPartCode partcode)"},
+ {"DrawThemeScrollBarDelimiters", (PyCFunction)App_DrawThemeScrollBarDelimiters, 1,
+ "(ThemeWindowType flavor, Rect inContRect, ThemeDrawState state, ThemeWindowAttributes attributes) -> None"},
+ {"PlayThemeSound", (PyCFunction)App_PlayThemeSound, 1,
+ "(ThemeSoundKind kind) -> None"},
+ {"BeginThemeDragSound", (PyCFunction)App_BeginThemeDragSound, 1,
+ "(ThemeDragSoundKind kind) -> None"},
+ {"EndThemeDragSound", (PyCFunction)App_EndThemeDragSound, 1,
+ "() -> None"},
+ {"DrawThemeTickMark", (PyCFunction)App_DrawThemeTickMark, 1,
+ "(Rect bounds, ThemeDrawState state) -> None"},
+ {"DrawThemeStandaloneGrowBox", (PyCFunction)App_DrawThemeStandaloneGrowBox, 1,
+ "(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None"},
+ {"DrawThemeStandaloneNoGrowBox", (PyCFunction)App_DrawThemeStandaloneNoGrowBox, 1,
+ "(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None"},
+ {"GetThemeStandaloneGrowBoxBounds", (PyCFunction)App_GetThemeStandaloneGrowBoxBounds, 1,
+ "(Point origin, ThemeGrowDirection growDirection, Boolean isSmall) -> (Rect bounds)"},
+ {"NormalizeThemeDrawingState", (PyCFunction)App_NormalizeThemeDrawingState, 1,
+ "() -> None"},
+ {"ApplyThemeBackground", (PyCFunction)App_ApplyThemeBackground, 1,
+ "(ThemeBackgroundKind inKind, Rect bounds, ThemeDrawState inState, SInt16 inDepth, Boolean inColorDev) -> None"},
+ {"SetThemeTextColorForWindow", (PyCFunction)App_SetThemeTextColorForWindow, 1,
+ "(WindowPtr window, Boolean isActive, SInt16 depth, Boolean isColorDev) -> None"},
+ {"IsValidAppearanceFileType", (PyCFunction)App_IsValidAppearanceFileType, 1,
+ "(OSType fileType) -> (Boolean _rv)"},
+ {"GetThemeBrushAsColor", (PyCFunction)App_GetThemeBrushAsColor, 1,
+ "(ThemeBrush inBrush, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)"},
+ {"GetThemeTextColor", (PyCFunction)App_GetThemeTextColor, 1,
+ "(ThemeTextColor inColor, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)"},
+
+#if TARGET_API_MAC_CARBON
+ {"GetThemeMetric", (PyCFunction)App_GetThemeMetric, 1,
+ "(ThemeMetric inMetric) -> (SInt32 outMetric)"},
+#endif
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_App(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+ m = Py_InitModule("_App", App_methods);
+ d = PyModule_GetDict(m);
+ App_Error = PyMac_GetOSErrException();
+ if (App_Error == NULL ||
+ PyDict_SetItemString(d, "Error", App_Error) != 0)
+ return;
+}
+
+/* ======================== End module _App ========================= */
+
--- /dev/null
+
+/* =========================== Module _CF =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <CFBase.h>
+#include <CFArray.h>
+#include <CFData.h>
+#include <CFDictionary.h>
+#include <CFString.h>
+#include <CFURL.h>
+#else
+#include <CoreServices/CoreServices.h>
+#endif
+
+/* For now we declare them forward here. They'll go to mactoolbox later */
+staticforward PyObject *CFTypeRefObj_New(CFTypeRef);
+staticforward int CFTypeRefObj_Convert(PyObject *, CFTypeRef *);
+staticforward PyObject *CFStringRefObj_New(CFStringRef);
+staticforward int CFStringRefObj_Convert(PyObject *, CFStringRef *);
+staticforward PyObject *CFURLRefObj_New(CFURLRef);
+staticforward int CFURLRefObj_Convert(PyObject *, CFURLRef *);
+
+staticforward int CFURLRefObj_Convert(PyObject *, CFURLRef *);
+
+// ADD declarations
+#ifdef NOTYET_USE_TOOLBOX_OBJECT_GLUE
+//extern PyObject *_CFTypeRefObj_New(CFTypeRef);
+//extern int _CFTypeRefObj_Convert(PyObject *, CFTypeRef *);
+
+//#define CFTypeRefObj_New _CFTypeRefObj_New
+//#define CFTypeRefObj_Convert _CFTypeRefObj_Convert
+#endif
+
+/*
+** Parse/generate CFRange records
+*/
+PyObject *CFRange_New(CFRange *itself)
+{
+
+ return Py_BuildValue("ll", (long)itself->location, (long)itself->length);
+}
+
+CFRange_Convert(PyObject *v, CFRange *p_itself)
+{
+ long location, length;
+
+ if( !PyArg_ParseTuple(v, "ll", &location, &length) )
+ return 0;
+ p_itself->location = (CFIndex)location;
+ p_itself->length = (CFIndex)length;
+ return 1;
+}
+
+/* Optional CFURL argument or None (passed as NULL) */
+int
+OptionalCFURLRefObj_Convert(PyObject *v, CFURLRef *p_itself)
+{
+ if ( v == Py_None ) {
+ p_itself = NULL;
+ return 1;
+ }
+ return CFURLRefObj_Convert(v, p_itself);
+}
+
+
+static PyObject *CF_Error;
+
+/* --------------------- Object type CFTypeRef ---------------------- */
+
+PyTypeObject CFTypeRef_Type;
+
+#define CFTypeRefObj_Check(x) ((x)->ob_type == &CFTypeRef_Type)
+
+typedef struct CFTypeRefObject {
+ PyObject_HEAD
+ CFTypeRef ob_itself;
+ void (*ob_freeit)(CFTypeRef ptr);
+} CFTypeRefObject;
+
+PyObject *CFTypeRefObj_New(CFTypeRef itself)
+{
+ CFTypeRefObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(CFTypeRefObject, &CFTypeRef_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_freeit = CFRelease;
+ return (PyObject *)it;
+}
+CFTypeRefObj_Convert(PyObject *v, CFTypeRef *p_itself)
+{
+
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ /* Check for other CF objects here */
+
+ if (!CFTypeRefObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "CFTypeRef required");
+ return 0;
+ }
+ *p_itself = ((CFTypeRefObject *)v)->ob_itself;
+ return 1;
+}
+
+static void CFTypeRefObj_dealloc(CFTypeRefObject *self)
+{
+ if (self->ob_freeit && self->ob_itself)
+ {
+ self->ob_freeit((CFTypeRef)self->ob_itself);
+ }
+ PyMem_DEL(self);
+}
+
+static PyObject *CFTypeRefObj_CFGetTypeID(CFTypeRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFTypeID _rv;
+ PyMac_PRECHECK(CFGetTypeID);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFGetTypeID(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFTypeRefObj_CFRetain(CFTypeRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFTypeRef _rv;
+ PyMac_PRECHECK(CFRetain);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFRetain(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFTypeRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFTypeRefObj_CFRelease(CFTypeRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyMac_PRECHECK(CFRelease);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ CFRelease(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFTypeRefObj_CFGetRetainCount(CFTypeRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFIndex _rv;
+ PyMac_PRECHECK(CFGetRetainCount);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFGetRetainCount(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFTypeRefObj_CFEqual(CFTypeRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ CFTypeRef cf2;
+ PyMac_PRECHECK(CFEqual);
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFTypeRefObj_Convert, &cf2))
+ return NULL;
+ _rv = CFEqual(_self->ob_itself,
+ cf2);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFTypeRefObj_CFHash(CFTypeRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFHashCode _rv;
+ PyMac_PRECHECK(CFHash);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFHash(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFTypeRefObj_CFCopyDescription(CFTypeRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ PyMac_PRECHECK(CFCopyDescription);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFCopyDescription(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFTypeRefObj_CFShow(CFTypeRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyMac_PRECHECK(CFShow);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ CFShow(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef CFTypeRefObj_methods[] = {
+ {"CFGetTypeID", (PyCFunction)CFTypeRefObj_CFGetTypeID, 1,
+ "() -> (CFTypeID _rv)"},
+ {"CFRetain", (PyCFunction)CFTypeRefObj_CFRetain, 1,
+ "() -> (CFTypeRef _rv)"},
+ {"CFRelease", (PyCFunction)CFTypeRefObj_CFRelease, 1,
+ "() -> None"},
+ {"CFGetRetainCount", (PyCFunction)CFTypeRefObj_CFGetRetainCount, 1,
+ "() -> (CFIndex _rv)"},
+ {"CFEqual", (PyCFunction)CFTypeRefObj_CFEqual, 1,
+ "(CFTypeRef cf2) -> (Boolean _rv)"},
+ {"CFHash", (PyCFunction)CFTypeRefObj_CFHash, 1,
+ "() -> (CFHashCode _rv)"},
+ {"CFCopyDescription", (PyCFunction)CFTypeRefObj_CFCopyDescription, 1,
+ "() -> (CFStringRef _rv)"},
+ {"CFShow", (PyCFunction)CFTypeRefObj_CFShow, 1,
+ "() -> None"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain CFTypeRefObj_chain = { CFTypeRefObj_methods, NULL };
+
+static PyObject *CFTypeRefObj_getattr(CFTypeRefObject *self, char *name)
+{
+ return Py_FindMethodInChain(&CFTypeRefObj_chain, (PyObject *)self, name);
+}
+
+#define CFTypeRefObj_setattr NULL
+
+static int CFTypeRefObj_compare(CFTypeRefObject *self, CFTypeRefObject *other)
+{
+ /* XXXX Or should we use CFEqual?? */
+ if ( self->ob_itself > other->ob_itself ) return 1;
+ if ( self->ob_itself < other->ob_itself ) return -1;
+ return 0;
+}
+
+static PyObject * CFTypeRefObj_repr(CFTypeRefObject *self)
+{
+ char buf[100];
+ sprintf(buf, "<CFTypeRef type-%d object at 0x%08.8x for 0x%08.8x>", CFGetTypeID(self->ob_itself), self, self->ob_itself);
+ return PyString_FromString(buf);
+}
+
+static int CFTypeRefObj_hash(CFTypeRefObject *self)
+{
+ /* XXXX Or should we use CFHash?? */
+ return (int)self->ob_itself;
+}
+
+PyTypeObject CFTypeRef_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "CFTypeRef", /*tp_name*/
+ sizeof(CFTypeRefObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) CFTypeRefObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) CFTypeRefObj_getattr, /*tp_getattr*/
+ (setattrfunc) CFTypeRefObj_setattr, /*tp_setattr*/
+ (cmpfunc) CFTypeRefObj_compare, /*tp_compare*/
+ (reprfunc) CFTypeRefObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) CFTypeRefObj_hash, /*tp_hash*/
+};
+
+/* ------------------- End object type CFTypeRef -------------------- */
+
+
+/* --------------------- Object type CFArrayRef --------------------- */
+
+PyTypeObject CFArrayRef_Type;
+
+#define CFArrayRefObj_Check(x) ((x)->ob_type == &CFArrayRef_Type)
+
+typedef struct CFArrayRefObject {
+ PyObject_HEAD
+ CFArrayRef ob_itself;
+ void (*ob_freeit)(CFTypeRef ptr);
+} CFArrayRefObject;
+
+PyObject *CFArrayRefObj_New(CFArrayRef itself)
+{
+ CFArrayRefObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(CFArrayRefObject, &CFArrayRef_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_freeit = CFRelease;
+ return (PyObject *)it;
+}
+CFArrayRefObj_Convert(PyObject *v, CFArrayRef *p_itself)
+{
+
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ /* Check for other CF objects here */
+
+ if (!CFArrayRefObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "CFArrayRef required");
+ return 0;
+ }
+ *p_itself = ((CFArrayRefObject *)v)->ob_itself;
+ return 1;
+}
+
+static void CFArrayRefObj_dealloc(CFArrayRefObject *self)
+{
+ if (self->ob_freeit && self->ob_itself)
+ {
+ self->ob_freeit((CFTypeRef)self->ob_itself);
+ }
+ PyMem_DEL(self);
+}
+
+static PyObject *CFArrayRefObj_CFArrayCreateCopy(CFArrayRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFArrayRef _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFArrayCreateCopy((CFAllocatorRef)NULL,
+ _self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFArrayRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFArrayRefObj_CFArrayGetCount(CFArrayRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFIndex _rv;
+ PyMac_PRECHECK(CFArrayGetCount);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFArrayGetCount(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFArrayRefObj_CFStringCreateByCombiningStrings(CFArrayRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ CFStringRef separatorString;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &separatorString))
+ return NULL;
+ _rv = CFStringCreateByCombiningStrings((CFAllocatorRef)NULL,
+ _self->ob_itself,
+ separatorString);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyMethodDef CFArrayRefObj_methods[] = {
+ {"CFArrayCreateCopy", (PyCFunction)CFArrayRefObj_CFArrayCreateCopy, 1,
+ "() -> (CFArrayRef _rv)"},
+ {"CFArrayGetCount", (PyCFunction)CFArrayRefObj_CFArrayGetCount, 1,
+ "() -> (CFIndex _rv)"},
+ {"CFStringCreateByCombiningStrings", (PyCFunction)CFArrayRefObj_CFStringCreateByCombiningStrings, 1,
+ "(CFStringRef separatorString) -> (CFStringRef _rv)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain CFArrayRefObj_chain = { CFArrayRefObj_methods, &CFTypeRefObj_chain };
+
+static PyObject *CFArrayRefObj_getattr(CFArrayRefObject *self, char *name)
+{
+ return Py_FindMethodInChain(&CFArrayRefObj_chain, (PyObject *)self, name);
+}
+
+#define CFArrayRefObj_setattr NULL
+
+static int CFArrayRefObj_compare(CFArrayRefObject *self, CFArrayRefObject *other)
+{
+ /* XXXX Or should we use CFEqual?? */
+ if ( self->ob_itself > other->ob_itself ) return 1;
+ if ( self->ob_itself < other->ob_itself ) return -1;
+ return 0;
+}
+
+static PyObject * CFArrayRefObj_repr(CFArrayRefObject *self)
+{
+ char buf[100];
+ sprintf(buf, "<CFArrayRef object at 0x%08.8x for 0x%08.8x>", self, self->ob_itself);
+ return PyString_FromString(buf);
+}
+
+static int CFArrayRefObj_hash(CFArrayRefObject *self)
+{
+ /* XXXX Or should we use CFHash?? */
+ return (int)self->ob_itself;
+}
+
+PyTypeObject CFArrayRef_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "CFArrayRef", /*tp_name*/
+ sizeof(CFArrayRefObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) CFArrayRefObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) CFArrayRefObj_getattr, /*tp_getattr*/
+ (setattrfunc) CFArrayRefObj_setattr, /*tp_setattr*/
+ (cmpfunc) CFArrayRefObj_compare, /*tp_compare*/
+ (reprfunc) CFArrayRefObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) CFArrayRefObj_hash, /*tp_hash*/
+};
+
+/* ------------------- End object type CFArrayRef ------------------- */
+
+
+/* ----------------- Object type CFMutableArrayRef ------------------ */
+
+PyTypeObject CFMutableArrayRef_Type;
+
+#define CFMutableArrayRefObj_Check(x) ((x)->ob_type == &CFMutableArrayRef_Type)
+
+typedef struct CFMutableArrayRefObject {
+ PyObject_HEAD
+ CFMutableArrayRef ob_itself;
+ void (*ob_freeit)(CFTypeRef ptr);
+} CFMutableArrayRefObject;
+
+PyObject *CFMutableArrayRefObj_New(CFMutableArrayRef itself)
+{
+ CFMutableArrayRefObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(CFMutableArrayRefObject, &CFMutableArrayRef_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_freeit = CFRelease;
+ return (PyObject *)it;
+}
+CFMutableArrayRefObj_Convert(PyObject *v, CFMutableArrayRef *p_itself)
+{
+
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ /* Check for other CF objects here */
+
+ if (!CFMutableArrayRefObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "CFMutableArrayRef required");
+ return 0;
+ }
+ *p_itself = ((CFMutableArrayRefObject *)v)->ob_itself;
+ return 1;
+}
+
+static void CFMutableArrayRefObj_dealloc(CFMutableArrayRefObject *self)
+{
+ if (self->ob_freeit && self->ob_itself)
+ {
+ self->ob_freeit((CFTypeRef)self->ob_itself);
+ }
+ PyMem_DEL(self);
+}
+
+static PyObject *CFMutableArrayRefObj_CFArrayRemoveValueAtIndex(CFMutableArrayRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFIndex idx;
+ PyMac_PRECHECK(CFArrayRemoveValueAtIndex);
+ if (!PyArg_ParseTuple(_args, "l",
+ &idx))
+ return NULL;
+ CFArrayRemoveValueAtIndex(_self->ob_itself,
+ idx);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFMutableArrayRefObj_CFArrayRemoveAllValues(CFMutableArrayRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyMac_PRECHECK(CFArrayRemoveAllValues);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ CFArrayRemoveAllValues(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices(CFMutableArrayRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFIndex idx1;
+ CFIndex idx2;
+ PyMac_PRECHECK(CFArrayExchangeValuesAtIndices);
+ if (!PyArg_ParseTuple(_args, "ll",
+ &idx1,
+ &idx2))
+ return NULL;
+ CFArrayExchangeValuesAtIndices(_self->ob_itself,
+ idx1,
+ idx2);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef CFMutableArrayRefObj_methods[] = {
+ {"CFArrayRemoveValueAtIndex", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveValueAtIndex, 1,
+ "(CFIndex idx) -> None"},
+ {"CFArrayRemoveAllValues", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveAllValues, 1,
+ "() -> None"},
+ {"CFArrayExchangeValuesAtIndices", (PyCFunction)CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices, 1,
+ "(CFIndex idx1, CFIndex idx2) -> None"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain CFMutableArrayRefObj_chain = { CFMutableArrayRefObj_methods, &CFArrayRefObj_chain };
+
+static PyObject *CFMutableArrayRefObj_getattr(CFMutableArrayRefObject *self, char *name)
+{
+ return Py_FindMethodInChain(&CFMutableArrayRefObj_chain, (PyObject *)self, name);
+}
+
+#define CFMutableArrayRefObj_setattr NULL
+
+static int CFMutableArrayRefObj_compare(CFMutableArrayRefObject *self, CFMutableArrayRefObject *other)
+{
+ /* XXXX Or should we use CFEqual?? */
+ if ( self->ob_itself > other->ob_itself ) return 1;
+ if ( self->ob_itself < other->ob_itself ) return -1;
+ return 0;
+}
+
+static PyObject * CFMutableArrayRefObj_repr(CFMutableArrayRefObject *self)
+{
+ char buf[100];
+ sprintf(buf, "<CFMutableArrayRef object at 0x%08.8x for 0x%08.8x>", self, self->ob_itself);
+ return PyString_FromString(buf);
+}
+
+static int CFMutableArrayRefObj_hash(CFMutableArrayRefObject *self)
+{
+ /* XXXX Or should we use CFHash?? */
+ return (int)self->ob_itself;
+}
+
+PyTypeObject CFMutableArrayRef_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "CFMutableArrayRef", /*tp_name*/
+ sizeof(CFMutableArrayRefObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) CFMutableArrayRefObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) CFMutableArrayRefObj_getattr, /*tp_getattr*/
+ (setattrfunc) CFMutableArrayRefObj_setattr, /*tp_setattr*/
+ (cmpfunc) CFMutableArrayRefObj_compare, /*tp_compare*/
+ (reprfunc) CFMutableArrayRefObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) CFMutableArrayRefObj_hash, /*tp_hash*/
+};
+
+/* --------------- End object type CFMutableArrayRef ---------------- */
+
+
+/* ------------------ Object type CFDictionaryRef ------------------- */
+
+PyTypeObject CFDictionaryRef_Type;
+
+#define CFDictionaryRefObj_Check(x) ((x)->ob_type == &CFDictionaryRef_Type)
+
+typedef struct CFDictionaryRefObject {
+ PyObject_HEAD
+ CFDictionaryRef ob_itself;
+ void (*ob_freeit)(CFTypeRef ptr);
+} CFDictionaryRefObject;
+
+PyObject *CFDictionaryRefObj_New(CFDictionaryRef itself)
+{
+ CFDictionaryRefObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(CFDictionaryRefObject, &CFDictionaryRef_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_freeit = CFRelease;
+ return (PyObject *)it;
+}
+CFDictionaryRefObj_Convert(PyObject *v, CFDictionaryRef *p_itself)
+{
+
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ /* Check for other CF objects here */
+
+ if (!CFDictionaryRefObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "CFDictionaryRef required");
+ return 0;
+ }
+ *p_itself = ((CFDictionaryRefObject *)v)->ob_itself;
+ return 1;
+}
+
+static void CFDictionaryRefObj_dealloc(CFDictionaryRefObject *self)
+{
+ if (self->ob_freeit && self->ob_itself)
+ {
+ self->ob_freeit((CFTypeRef)self->ob_itself);
+ }
+ PyMem_DEL(self);
+}
+
+static PyObject *CFDictionaryRefObj_CFDictionaryCreateCopy(CFDictionaryRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFDictionaryRef _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFDictionaryCreateCopy((CFAllocatorRef)NULL,
+ _self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFDictionaryRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFDictionaryRefObj_CFDictionaryGetCount(CFDictionaryRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFIndex _rv;
+ PyMac_PRECHECK(CFDictionaryGetCount);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFDictionaryGetCount(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyMethodDef CFDictionaryRefObj_methods[] = {
+ {"CFDictionaryCreateCopy", (PyCFunction)CFDictionaryRefObj_CFDictionaryCreateCopy, 1,
+ "() -> (CFDictionaryRef _rv)"},
+ {"CFDictionaryGetCount", (PyCFunction)CFDictionaryRefObj_CFDictionaryGetCount, 1,
+ "() -> (CFIndex _rv)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain CFDictionaryRefObj_chain = { CFDictionaryRefObj_methods, &CFTypeRefObj_chain };
+
+static PyObject *CFDictionaryRefObj_getattr(CFDictionaryRefObject *self, char *name)
+{
+ return Py_FindMethodInChain(&CFDictionaryRefObj_chain, (PyObject *)self, name);
+}
+
+#define CFDictionaryRefObj_setattr NULL
+
+static int CFDictionaryRefObj_compare(CFDictionaryRefObject *self, CFDictionaryRefObject *other)
+{
+ /* XXXX Or should we use CFEqual?? */
+ if ( self->ob_itself > other->ob_itself ) return 1;
+ if ( self->ob_itself < other->ob_itself ) return -1;
+ return 0;
+}
+
+static PyObject * CFDictionaryRefObj_repr(CFDictionaryRefObject *self)
+{
+ char buf[100];
+ sprintf(buf, "<CFDictionaryRef object at 0x%08.8x for 0x%08.8x>", self, self->ob_itself);
+ return PyString_FromString(buf);
+}
+
+static int CFDictionaryRefObj_hash(CFDictionaryRefObject *self)
+{
+ /* XXXX Or should we use CFHash?? */
+ return (int)self->ob_itself;
+}
+
+PyTypeObject CFDictionaryRef_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "CFDictionaryRef", /*tp_name*/
+ sizeof(CFDictionaryRefObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) CFDictionaryRefObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) CFDictionaryRefObj_getattr, /*tp_getattr*/
+ (setattrfunc) CFDictionaryRefObj_setattr, /*tp_setattr*/
+ (cmpfunc) CFDictionaryRefObj_compare, /*tp_compare*/
+ (reprfunc) CFDictionaryRefObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) CFDictionaryRefObj_hash, /*tp_hash*/
+};
+
+/* ---------------- End object type CFDictionaryRef ----------------- */
+
+
+/* --------------- Object type CFMutableDictionaryRef --------------- */
+
+PyTypeObject CFMutableDictionaryRef_Type;
+
+#define CFMutableDictionaryRefObj_Check(x) ((x)->ob_type == &CFMutableDictionaryRef_Type)
+
+typedef struct CFMutableDictionaryRefObject {
+ PyObject_HEAD
+ CFMutableDictionaryRef ob_itself;
+ void (*ob_freeit)(CFTypeRef ptr);
+} CFMutableDictionaryRefObject;
+
+PyObject *CFMutableDictionaryRefObj_New(CFMutableDictionaryRef itself)
+{
+ CFMutableDictionaryRefObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(CFMutableDictionaryRefObject, &CFMutableDictionaryRef_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_freeit = CFRelease;
+ return (PyObject *)it;
+}
+CFMutableDictionaryRefObj_Convert(PyObject *v, CFMutableDictionaryRef *p_itself)
+{
+
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ /* Check for other CF objects here */
+
+ if (!CFMutableDictionaryRefObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "CFMutableDictionaryRef required");
+ return 0;
+ }
+ *p_itself = ((CFMutableDictionaryRefObject *)v)->ob_itself;
+ return 1;
+}
+
+static void CFMutableDictionaryRefObj_dealloc(CFMutableDictionaryRefObject *self)
+{
+ if (self->ob_freeit && self->ob_itself)
+ {
+ self->ob_freeit((CFTypeRef)self->ob_itself);
+ }
+ PyMem_DEL(self);
+}
+
+static PyObject *CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues(CFMutableDictionaryRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyMac_PRECHECK(CFDictionaryRemoveAllValues);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ CFDictionaryRemoveAllValues(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef CFMutableDictionaryRefObj_methods[] = {
+ {"CFDictionaryRemoveAllValues", (PyCFunction)CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues, 1,
+ "() -> None"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain CFMutableDictionaryRefObj_chain = { CFMutableDictionaryRefObj_methods, &CFDictionaryRefObj_chain };
+
+static PyObject *CFMutableDictionaryRefObj_getattr(CFMutableDictionaryRefObject *self, char *name)
+{
+ return Py_FindMethodInChain(&CFMutableDictionaryRefObj_chain, (PyObject *)self, name);
+}
+
+#define CFMutableDictionaryRefObj_setattr NULL
+
+static int CFMutableDictionaryRefObj_compare(CFMutableDictionaryRefObject *self, CFMutableDictionaryRefObject *other)
+{
+ /* XXXX Or should we use CFEqual?? */
+ if ( self->ob_itself > other->ob_itself ) return 1;
+ if ( self->ob_itself < other->ob_itself ) return -1;
+ return 0;
+}
+
+static PyObject * CFMutableDictionaryRefObj_repr(CFMutableDictionaryRefObject *self)
+{
+ char buf[100];
+ sprintf(buf, "<CFMutableDictionaryRef object at 0x%08.8x for 0x%08.8x>", self, self->ob_itself);
+ return PyString_FromString(buf);
+}
+
+static int CFMutableDictionaryRefObj_hash(CFMutableDictionaryRefObject *self)
+{
+ /* XXXX Or should we use CFHash?? */
+ return (int)self->ob_itself;
+}
+
+PyTypeObject CFMutableDictionaryRef_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "CFMutableDictionaryRef", /*tp_name*/
+ sizeof(CFMutableDictionaryRefObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) CFMutableDictionaryRefObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) CFMutableDictionaryRefObj_getattr, /*tp_getattr*/
+ (setattrfunc) CFMutableDictionaryRefObj_setattr, /*tp_setattr*/
+ (cmpfunc) CFMutableDictionaryRefObj_compare, /*tp_compare*/
+ (reprfunc) CFMutableDictionaryRefObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) CFMutableDictionaryRefObj_hash, /*tp_hash*/
+};
+
+/* ------------- End object type CFMutableDictionaryRef ------------- */
+
+
+/* --------------------- Object type CFDataRef ---------------------- */
+
+PyTypeObject CFDataRef_Type;
+
+#define CFDataRefObj_Check(x) ((x)->ob_type == &CFDataRef_Type)
+
+typedef struct CFDataRefObject {
+ PyObject_HEAD
+ CFDataRef ob_itself;
+ void (*ob_freeit)(CFTypeRef ptr);
+} CFDataRefObject;
+
+PyObject *CFDataRefObj_New(CFDataRef itself)
+{
+ CFDataRefObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(CFDataRefObject, &CFDataRef_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_freeit = CFRelease;
+ return (PyObject *)it;
+}
+CFDataRefObj_Convert(PyObject *v, CFDataRef *p_itself)
+{
+
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ /* Check for other CF objects here */
+
+ if (!CFDataRefObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "CFDataRef required");
+ return 0;
+ }
+ *p_itself = ((CFDataRefObject *)v)->ob_itself;
+ return 1;
+}
+
+static void CFDataRefObj_dealloc(CFDataRefObject *self)
+{
+ if (self->ob_freeit && self->ob_itself)
+ {
+ self->ob_freeit((CFTypeRef)self->ob_itself);
+ }
+ PyMem_DEL(self);
+}
+
+static PyObject *CFDataRefObj_CFDataCreateCopy(CFDataRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFDataRef _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFDataCreateCopy((CFAllocatorRef)NULL,
+ _self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFDataRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFDataRefObj_CFDataGetLength(CFDataRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFIndex _rv;
+ PyMac_PRECHECK(CFDataGetLength);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFDataGetLength(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFDataRefObj_CFStringCreateFromExternalRepresentation(CFDataRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ CFStringEncoding encoding;
+ if (!PyArg_ParseTuple(_args, "l",
+ &encoding))
+ return NULL;
+ _rv = CFStringCreateFromExternalRepresentation((CFAllocatorRef)NULL,
+ _self->ob_itself,
+ encoding);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyMethodDef CFDataRefObj_methods[] = {
+ {"CFDataCreateCopy", (PyCFunction)CFDataRefObj_CFDataCreateCopy, 1,
+ "() -> (CFDataRef _rv)"},
+ {"CFDataGetLength", (PyCFunction)CFDataRefObj_CFDataGetLength, 1,
+ "() -> (CFIndex _rv)"},
+ {"CFStringCreateFromExternalRepresentation", (PyCFunction)CFDataRefObj_CFStringCreateFromExternalRepresentation, 1,
+ "(CFStringEncoding encoding) -> (CFStringRef _rv)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain CFDataRefObj_chain = { CFDataRefObj_methods, &CFTypeRefObj_chain };
+
+static PyObject *CFDataRefObj_getattr(CFDataRefObject *self, char *name)
+{
+ return Py_FindMethodInChain(&CFDataRefObj_chain, (PyObject *)self, name);
+}
+
+#define CFDataRefObj_setattr NULL
+
+static int CFDataRefObj_compare(CFDataRefObject *self, CFDataRefObject *other)
+{
+ /* XXXX Or should we use CFEqual?? */
+ if ( self->ob_itself > other->ob_itself ) return 1;
+ if ( self->ob_itself < other->ob_itself ) return -1;
+ return 0;
+}
+
+static PyObject * CFDataRefObj_repr(CFDataRefObject *self)
+{
+ char buf[100];
+ sprintf(buf, "<CFDataRef object at 0x%08.8x for 0x%08.8x>", self, self->ob_itself);
+ return PyString_FromString(buf);
+}
+
+static int CFDataRefObj_hash(CFDataRefObject *self)
+{
+ /* XXXX Or should we use CFHash?? */
+ return (int)self->ob_itself;
+}
+
+PyTypeObject CFDataRef_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "CFDataRef", /*tp_name*/
+ sizeof(CFDataRefObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) CFDataRefObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) CFDataRefObj_getattr, /*tp_getattr*/
+ (setattrfunc) CFDataRefObj_setattr, /*tp_setattr*/
+ (cmpfunc) CFDataRefObj_compare, /*tp_compare*/
+ (reprfunc) CFDataRefObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) CFDataRefObj_hash, /*tp_hash*/
+};
+
+/* ------------------- End object type CFDataRef -------------------- */
+
+
+/* ------------------ Object type CFMutableDataRef ------------------ */
+
+PyTypeObject CFMutableDataRef_Type;
+
+#define CFMutableDataRefObj_Check(x) ((x)->ob_type == &CFMutableDataRef_Type)
+
+typedef struct CFMutableDataRefObject {
+ PyObject_HEAD
+ CFMutableDataRef ob_itself;
+ void (*ob_freeit)(CFTypeRef ptr);
+} CFMutableDataRefObject;
+
+PyObject *CFMutableDataRefObj_New(CFMutableDataRef itself)
+{
+ CFMutableDataRefObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(CFMutableDataRefObject, &CFMutableDataRef_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_freeit = CFRelease;
+ return (PyObject *)it;
+}
+CFMutableDataRefObj_Convert(PyObject *v, CFMutableDataRef *p_itself)
+{
+
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ /* Check for other CF objects here */
+
+ if (!CFMutableDataRefObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "CFMutableDataRef required");
+ return 0;
+ }
+ *p_itself = ((CFMutableDataRefObject *)v)->ob_itself;
+ return 1;
+}
+
+static void CFMutableDataRefObj_dealloc(CFMutableDataRefObject *self)
+{
+ if (self->ob_freeit && self->ob_itself)
+ {
+ self->ob_freeit((CFTypeRef)self->ob_itself);
+ }
+ PyMem_DEL(self);
+}
+
+static PyObject *CFMutableDataRefObj_CFDataSetLength(CFMutableDataRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFIndex length;
+ PyMac_PRECHECK(CFDataSetLength);
+ if (!PyArg_ParseTuple(_args, "l",
+ &length))
+ return NULL;
+ CFDataSetLength(_self->ob_itself,
+ length);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFMutableDataRefObj_CFDataIncreaseLength(CFMutableDataRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFIndex extraLength;
+ PyMac_PRECHECK(CFDataIncreaseLength);
+ if (!PyArg_ParseTuple(_args, "l",
+ &extraLength))
+ return NULL;
+ CFDataIncreaseLength(_self->ob_itself,
+ extraLength);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFMutableDataRefObj_CFDataAppendBytes(CFMutableDataRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ unsigned char *bytes__in__;
+ long bytes__len__;
+ int bytes__in_len__;
+ PyMac_PRECHECK(CFDataAppendBytes);
+ if (!PyArg_ParseTuple(_args, "s#",
+ &bytes__in__, &bytes__in_len__))
+ return NULL;
+ bytes__len__ = bytes__in_len__;
+ CFDataAppendBytes(_self->ob_itself,
+ bytes__in__, bytes__len__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ bytes__error__: ;
+ return _res;
+}
+
+static PyObject *CFMutableDataRefObj_CFDataReplaceBytes(CFMutableDataRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFRange range;
+ unsigned char *newBytes__in__;
+ long newBytes__len__;
+ int newBytes__in_len__;
+ PyMac_PRECHECK(CFDataReplaceBytes);
+ if (!PyArg_ParseTuple(_args, "O&s#",
+ CFRange_Convert, &range,
+ &newBytes__in__, &newBytes__in_len__))
+ return NULL;
+ newBytes__len__ = newBytes__in_len__;
+ CFDataReplaceBytes(_self->ob_itself,
+ range,
+ newBytes__in__, newBytes__len__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ newBytes__error__: ;
+ return _res;
+}
+
+static PyObject *CFMutableDataRefObj_CFDataDeleteBytes(CFMutableDataRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFRange range;
+ PyMac_PRECHECK(CFDataDeleteBytes);
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFRange_Convert, &range))
+ return NULL;
+ CFDataDeleteBytes(_self->ob_itself,
+ range);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef CFMutableDataRefObj_methods[] = {
+ {"CFDataSetLength", (PyCFunction)CFMutableDataRefObj_CFDataSetLength, 1,
+ "(CFIndex length) -> None"},
+ {"CFDataIncreaseLength", (PyCFunction)CFMutableDataRefObj_CFDataIncreaseLength, 1,
+ "(CFIndex extraLength) -> None"},
+ {"CFDataAppendBytes", (PyCFunction)CFMutableDataRefObj_CFDataAppendBytes, 1,
+ "(Buffer bytes) -> None"},
+ {"CFDataReplaceBytes", (PyCFunction)CFMutableDataRefObj_CFDataReplaceBytes, 1,
+ "(CFRange range, Buffer newBytes) -> None"},
+ {"CFDataDeleteBytes", (PyCFunction)CFMutableDataRefObj_CFDataDeleteBytes, 1,
+ "(CFRange range) -> None"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain CFMutableDataRefObj_chain = { CFMutableDataRefObj_methods, &CFDataRefObj_chain };
+
+static PyObject *CFMutableDataRefObj_getattr(CFMutableDataRefObject *self, char *name)
+{
+ return Py_FindMethodInChain(&CFMutableDataRefObj_chain, (PyObject *)self, name);
+}
+
+#define CFMutableDataRefObj_setattr NULL
+
+static int CFMutableDataRefObj_compare(CFMutableDataRefObject *self, CFMutableDataRefObject *other)
+{
+ /* XXXX Or should we use CFEqual?? */
+ if ( self->ob_itself > other->ob_itself ) return 1;
+ if ( self->ob_itself < other->ob_itself ) return -1;
+ return 0;
+}
+
+static PyObject * CFMutableDataRefObj_repr(CFMutableDataRefObject *self)
+{
+ char buf[100];
+ sprintf(buf, "<CFMutableDataRef object at 0x%08.8x for 0x%08.8x>", self, self->ob_itself);
+ return PyString_FromString(buf);
+}
+
+static int CFMutableDataRefObj_hash(CFMutableDataRefObject *self)
+{
+ /* XXXX Or should we use CFHash?? */
+ return (int)self->ob_itself;
+}
+
+PyTypeObject CFMutableDataRef_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "CFMutableDataRef", /*tp_name*/
+ sizeof(CFMutableDataRefObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) CFMutableDataRefObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) CFMutableDataRefObj_getattr, /*tp_getattr*/
+ (setattrfunc) CFMutableDataRefObj_setattr, /*tp_setattr*/
+ (cmpfunc) CFMutableDataRefObj_compare, /*tp_compare*/
+ (reprfunc) CFMutableDataRefObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) CFMutableDataRefObj_hash, /*tp_hash*/
+};
+
+/* ---------------- End object type CFMutableDataRef ---------------- */
+
+
+/* -------------------- Object type CFStringRef --------------------- */
+
+PyTypeObject CFStringRef_Type;
+
+#define CFStringRefObj_Check(x) ((x)->ob_type == &CFStringRef_Type)
+
+typedef struct CFStringRefObject {
+ PyObject_HEAD
+ CFStringRef ob_itself;
+ void (*ob_freeit)(CFTypeRef ptr);
+} CFStringRefObject;
+
+PyObject *CFStringRefObj_New(CFStringRef itself)
+{
+ CFStringRefObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(CFStringRefObject, &CFStringRef_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_freeit = CFRelease;
+ return (PyObject *)it;
+}
+CFStringRefObj_Convert(PyObject *v, CFStringRef *p_itself)
+{
+
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ if (PyString_Check(v)) {
+ char *cStr = PyString_AsString(v);
+ *p_itself = CFStringCreateWithCString((CFAllocatorRef)NULL, cStr, 0);
+ return 1;
+ }
+ if (PyUnicode_Check(v)) {
+ /* We use the CF types here, if Python was configured differently that will give an error */
+ CFIndex size = PyUnicode_GetSize(v);
+ UniChar *unichars = PyUnicode_AsUnicode(v);
+ if (!unichars) return 0;
+ *p_itself = CFStringCreateWithCharacters((CFAllocatorRef)NULL, unichars, size);
+ return 1;
+ }
+
+
+ if (!CFStringRefObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "CFStringRef required");
+ return 0;
+ }
+ *p_itself = ((CFStringRefObject *)v)->ob_itself;
+ return 1;
+}
+
+static void CFStringRefObj_dealloc(CFStringRefObject *self)
+{
+ if (self->ob_freeit && self->ob_itself)
+ {
+ self->ob_freeit((CFTypeRef)self->ob_itself);
+ }
+ PyMem_DEL(self);
+}
+
+static PyObject *CFStringRefObj_CFStringCreateWithSubstring(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ CFRange range;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFRange_Convert, &range))
+ return NULL;
+ _rv = CFStringCreateWithSubstring((CFAllocatorRef)NULL,
+ _self->ob_itself,
+ range);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringCreateCopy(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFStringCreateCopy((CFAllocatorRef)NULL,
+ _self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringGetLength(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFIndex _rv;
+ PyMac_PRECHECK(CFStringGetLength);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFStringGetLength(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringGetBytes(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFIndex _rv;
+ CFRange range;
+ CFStringEncoding encoding;
+ UInt8 lossByte;
+ Boolean isExternalRepresentation;
+ UInt8 buffer;
+ CFIndex maxBufLen;
+ CFIndex usedBufLen;
+ PyMac_PRECHECK(CFStringGetBytes);
+ if (!PyArg_ParseTuple(_args, "O&lbll",
+ CFRange_Convert, &range,
+ &encoding,
+ &lossByte,
+ &isExternalRepresentation,
+ &maxBufLen))
+ return NULL;
+ _rv = CFStringGetBytes(_self->ob_itself,
+ range,
+ encoding,
+ lossByte,
+ isExternalRepresentation,
+ &buffer,
+ maxBufLen,
+ &usedBufLen);
+ _res = Py_BuildValue("lbl",
+ _rv,
+ buffer,
+ usedBufLen);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringCreateExternalRepresentation(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFDataRef _rv;
+ CFStringEncoding encoding;
+ UInt8 lossByte;
+ if (!PyArg_ParseTuple(_args, "lb",
+ &encoding,
+ &lossByte))
+ return NULL;
+ _rv = CFStringCreateExternalRepresentation((CFAllocatorRef)NULL,
+ _self->ob_itself,
+ encoding,
+ lossByte);
+ _res = Py_BuildValue("O&",
+ CFDataRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringGetSmallestEncoding(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringEncoding _rv;
+ PyMac_PRECHECK(CFStringGetSmallestEncoding);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFStringGetSmallestEncoding(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringGetFastestEncoding(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringEncoding _rv;
+ PyMac_PRECHECK(CFStringGetFastestEncoding);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFStringGetFastestEncoding(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringCompareWithOptions(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFComparisonResult _rv;
+ CFStringRef string2;
+ CFRange rangeToCompare;
+ CFOptionFlags compareOptions;
+ PyMac_PRECHECK(CFStringCompareWithOptions);
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ CFStringRefObj_Convert, &string2,
+ CFRange_Convert, &rangeToCompare,
+ &compareOptions))
+ return NULL;
+ _rv = CFStringCompareWithOptions(_self->ob_itself,
+ string2,
+ rangeToCompare,
+ compareOptions);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringCompare(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFComparisonResult _rv;
+ CFStringRef string2;
+ CFOptionFlags compareOptions;
+ PyMac_PRECHECK(CFStringCompare);
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CFStringRefObj_Convert, &string2,
+ &compareOptions))
+ return NULL;
+ _rv = CFStringCompare(_self->ob_itself,
+ string2,
+ compareOptions);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringFindWithOptions(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ CFStringRef stringToFind;
+ CFRange rangeToSearch;
+ CFOptionFlags searchOptions;
+ CFRange result;
+ PyMac_PRECHECK(CFStringFindWithOptions);
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ CFStringRefObj_Convert, &stringToFind,
+ CFRange_Convert, &rangeToSearch,
+ &searchOptions))
+ return NULL;
+ _rv = CFStringFindWithOptions(_self->ob_itself,
+ stringToFind,
+ rangeToSearch,
+ searchOptions,
+ &result);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ CFRange_New, result);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringCreateArrayWithFindResults(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFArrayRef _rv;
+ CFStringRef stringToFind;
+ CFRange rangeToSearch;
+ CFOptionFlags compareOptions;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ CFStringRefObj_Convert, &stringToFind,
+ CFRange_Convert, &rangeToSearch,
+ &compareOptions))
+ return NULL;
+ _rv = CFStringCreateArrayWithFindResults((CFAllocatorRef)NULL,
+ _self->ob_itself,
+ stringToFind,
+ rangeToSearch,
+ compareOptions);
+ _res = Py_BuildValue("O&",
+ CFArrayRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringFind(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFRange _rv;
+ CFStringRef stringToFind;
+ CFOptionFlags compareOptions;
+ PyMac_PRECHECK(CFStringFind);
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CFStringRefObj_Convert, &stringToFind,
+ &compareOptions))
+ return NULL;
+ _rv = CFStringFind(_self->ob_itself,
+ stringToFind,
+ compareOptions);
+ _res = Py_BuildValue("O&",
+ CFRange_New, _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringHasPrefix(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ CFStringRef prefix;
+ PyMac_PRECHECK(CFStringHasPrefix);
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &prefix))
+ return NULL;
+ _rv = CFStringHasPrefix(_self->ob_itself,
+ prefix);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringHasSuffix(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ CFStringRef suffix;
+ PyMac_PRECHECK(CFStringHasSuffix);
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &suffix))
+ return NULL;
+ _rv = CFStringHasSuffix(_self->ob_itself,
+ suffix);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringGetLineBounds(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFRange range;
+ CFIndex lineBeginIndex;
+ CFIndex lineEndIndex;
+ CFIndex contentsEndIndex;
+ PyMac_PRECHECK(CFStringGetLineBounds);
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFRange_Convert, &range))
+ return NULL;
+ CFStringGetLineBounds(_self->ob_itself,
+ range,
+ &lineBeginIndex,
+ &lineEndIndex,
+ &contentsEndIndex);
+ _res = Py_BuildValue("lll",
+ lineBeginIndex,
+ lineEndIndex,
+ contentsEndIndex);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringCreateArrayBySeparatingStrings(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFArrayRef _rv;
+ CFStringRef separatorString;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &separatorString))
+ return NULL;
+ _rv = CFStringCreateArrayBySeparatingStrings((CFAllocatorRef)NULL,
+ _self->ob_itself,
+ separatorString);
+ _res = Py_BuildValue("O&",
+ CFArrayRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringGetIntValue(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 _rv;
+ PyMac_PRECHECK(CFStringGetIntValue);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFStringGetIntValue(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringGetDoubleValue(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ double _rv;
+ PyMac_PRECHECK(CFStringGetDoubleValue);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFStringGetDoubleValue(_self->ob_itself);
+ _res = Py_BuildValue("d",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringConvertIANACharSetNameToEncoding(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringEncoding _rv;
+ PyMac_PRECHECK(CFStringConvertIANACharSetNameToEncoding);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFStringConvertIANACharSetNameToEncoding(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFShowStr(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyMac_PRECHECK(CFShowStr);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ CFShowStr(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFURLCreateWithString(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFURLRef _rv;
+ CFURLRef baseURL;
+ if (!PyArg_ParseTuple(_args, "O&",
+ OptionalCFURLRefObj_Convert, &baseURL))
+ return NULL;
+ _rv = CFURLCreateWithString((CFAllocatorRef)NULL,
+ _self->ob_itself,
+ baseURL);
+ _res = Py_BuildValue("O&",
+ CFURLRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFURLCreateWithFileSystemPath(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFURLRef _rv;
+ CFURLPathStyle pathStyle;
+ Boolean isDirectory;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &pathStyle,
+ &isDirectory))
+ return NULL;
+ _rv = CFURLCreateWithFileSystemPath((CFAllocatorRef)NULL,
+ _self->ob_itself,
+ pathStyle,
+ isDirectory);
+ _res = Py_BuildValue("O&",
+ CFURLRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFURLCreateStringByReplacingPercentEscapes(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ CFStringRef charactersToLeaveEscaped;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &charactersToLeaveEscaped))
+ return NULL;
+ _rv = CFURLCreateStringByReplacingPercentEscapes((CFAllocatorRef)NULL,
+ _self->ob_itself,
+ charactersToLeaveEscaped);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFStringRefObj_CFStringGetString(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ int size = CFStringGetLength(_self->ob_itself)+1;
+ char *data = malloc(size);
+
+ if( data == NULL ) return PyErr_NoMemory();
+ if ( CFStringGetCString(_self->ob_itself, data, size, 0) ) {
+ _res = (PyObject *)PyString_FromString(data);
+ } else {
+ PyErr_SetString(PyExc_RuntimeError, "CFStringGetCString could not fit the string");
+ _res = NULL;
+ }
+ free(data);
+ return _res;
+
+}
+
+static PyObject *CFStringRefObj_CFStringGetUnicode(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ int size = CFStringGetLength(_self->ob_itself)+1;
+ Py_UNICODE *data = malloc(size*sizeof(Py_UNICODE));
+ CFRange range;
+
+ range.location = 0;
+ range.length = size;
+ if( data == NULL ) return PyErr_NoMemory();
+ CFStringGetCharacters(_self->ob_itself, range, data);
+ _res = (PyObject *)PyUnicode_FromUnicode(data, size);
+ free(data);
+ return _res;
+
+}
+
+static PyMethodDef CFStringRefObj_methods[] = {
+ {"CFStringCreateWithSubstring", (PyCFunction)CFStringRefObj_CFStringCreateWithSubstring, 1,
+ "(CFRange range) -> (CFStringRef _rv)"},
+ {"CFStringCreateCopy", (PyCFunction)CFStringRefObj_CFStringCreateCopy, 1,
+ "() -> (CFStringRef _rv)"},
+ {"CFStringGetLength", (PyCFunction)CFStringRefObj_CFStringGetLength, 1,
+ "() -> (CFIndex _rv)"},
+ {"CFStringGetBytes", (PyCFunction)CFStringRefObj_CFStringGetBytes, 1,
+ "(CFRange range, CFStringEncoding encoding, UInt8 lossByte, Boolean isExternalRepresentation, CFIndex maxBufLen) -> (CFIndex _rv, UInt8 buffer, CFIndex usedBufLen)"},
+ {"CFStringCreateExternalRepresentation", (PyCFunction)CFStringRefObj_CFStringCreateExternalRepresentation, 1,
+ "(CFStringEncoding encoding, UInt8 lossByte) -> (CFDataRef _rv)"},
+ {"CFStringGetSmallestEncoding", (PyCFunction)CFStringRefObj_CFStringGetSmallestEncoding, 1,
+ "() -> (CFStringEncoding _rv)"},
+ {"CFStringGetFastestEncoding", (PyCFunction)CFStringRefObj_CFStringGetFastestEncoding, 1,
+ "() -> (CFStringEncoding _rv)"},
+ {"CFStringCompareWithOptions", (PyCFunction)CFStringRefObj_CFStringCompareWithOptions, 1,
+ "(CFStringRef string2, CFRange rangeToCompare, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)"},
+ {"CFStringCompare", (PyCFunction)CFStringRefObj_CFStringCompare, 1,
+ "(CFStringRef string2, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)"},
+ {"CFStringFindWithOptions", (PyCFunction)CFStringRefObj_CFStringFindWithOptions, 1,
+ "(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags searchOptions) -> (Boolean _rv, CFRange result)"},
+ {"CFStringCreateArrayWithFindResults", (PyCFunction)CFStringRefObj_CFStringCreateArrayWithFindResults, 1,
+ "(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags compareOptions) -> (CFArrayRef _rv)"},
+ {"CFStringFind", (PyCFunction)CFStringRefObj_CFStringFind, 1,
+ "(CFStringRef stringToFind, CFOptionFlags compareOptions) -> (CFRange _rv)"},
+ {"CFStringHasPrefix", (PyCFunction)CFStringRefObj_CFStringHasPrefix, 1,
+ "(CFStringRef prefix) -> (Boolean _rv)"},
+ {"CFStringHasSuffix", (PyCFunction)CFStringRefObj_CFStringHasSuffix, 1,
+ "(CFStringRef suffix) -> (Boolean _rv)"},
+ {"CFStringGetLineBounds", (PyCFunction)CFStringRefObj_CFStringGetLineBounds, 1,
+ "(CFRange range) -> (CFIndex lineBeginIndex, CFIndex lineEndIndex, CFIndex contentsEndIndex)"},
+ {"CFStringCreateArrayBySeparatingStrings", (PyCFunction)CFStringRefObj_CFStringCreateArrayBySeparatingStrings, 1,
+ "(CFStringRef separatorString) -> (CFArrayRef _rv)"},
+ {"CFStringGetIntValue", (PyCFunction)CFStringRefObj_CFStringGetIntValue, 1,
+ "() -> (SInt32 _rv)"},
+ {"CFStringGetDoubleValue", (PyCFunction)CFStringRefObj_CFStringGetDoubleValue, 1,
+ "() -> (double _rv)"},
+ {"CFStringConvertIANACharSetNameToEncoding", (PyCFunction)CFStringRefObj_CFStringConvertIANACharSetNameToEncoding, 1,
+ "() -> (CFStringEncoding _rv)"},
+ {"CFShowStr", (PyCFunction)CFStringRefObj_CFShowStr, 1,
+ "() -> None"},
+ {"CFURLCreateWithString", (PyCFunction)CFStringRefObj_CFURLCreateWithString, 1,
+ "(CFURLRef baseURL) -> (CFURLRef _rv)"},
+ {"CFURLCreateWithFileSystemPath", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPath, 1,
+ "(CFURLPathStyle pathStyle, Boolean isDirectory) -> (CFURLRef _rv)"},
+ {"CFURLCreateStringByReplacingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByReplacingPercentEscapes, 1,
+ "(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
+ {"CFStringGetString", (PyCFunction)CFStringRefObj_CFStringGetString, 1,
+ "() -> (string _rv)"},
+ {"CFStringGetUnicode", (PyCFunction)CFStringRefObj_CFStringGetUnicode, 1,
+ "() -> (unicode _rv)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain CFStringRefObj_chain = { CFStringRefObj_methods, &CFTypeRefObj_chain };
+
+static PyObject *CFStringRefObj_getattr(CFStringRefObject *self, char *name)
+{
+ return Py_FindMethodInChain(&CFStringRefObj_chain, (PyObject *)self, name);
+}
+
+#define CFStringRefObj_setattr NULL
+
+static int CFStringRefObj_compare(CFStringRefObject *self, CFStringRefObject *other)
+{
+ /* XXXX Or should we use CFEqual?? */
+ if ( self->ob_itself > other->ob_itself ) return 1;
+ if ( self->ob_itself < other->ob_itself ) return -1;
+ return 0;
+}
+
+static PyObject * CFStringRefObj_repr(CFStringRefObject *self)
+{
+ char buf[100];
+ sprintf(buf, "<CFStringRef object at 0x%08.8x for 0x%08.8x>", self, self->ob_itself);
+ return PyString_FromString(buf);
+}
+
+static int CFStringRefObj_hash(CFStringRefObject *self)
+{
+ /* XXXX Or should we use CFHash?? */
+ return (int)self->ob_itself;
+}
+
+PyTypeObject CFStringRef_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "CFStringRef", /*tp_name*/
+ sizeof(CFStringRefObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) CFStringRefObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) CFStringRefObj_getattr, /*tp_getattr*/
+ (setattrfunc) CFStringRefObj_setattr, /*tp_setattr*/
+ (cmpfunc) CFStringRefObj_compare, /*tp_compare*/
+ (reprfunc) CFStringRefObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) CFStringRefObj_hash, /*tp_hash*/
+};
+
+/* ------------------ End object type CFStringRef ------------------- */
+
+
+/* ----------------- Object type CFMutableStringRef ----------------- */
+
+PyTypeObject CFMutableStringRef_Type;
+
+#define CFMutableStringRefObj_Check(x) ((x)->ob_type == &CFMutableStringRef_Type)
+
+typedef struct CFMutableStringRefObject {
+ PyObject_HEAD
+ CFMutableStringRef ob_itself;
+ void (*ob_freeit)(CFTypeRef ptr);
+} CFMutableStringRefObject;
+
+PyObject *CFMutableStringRefObj_New(CFMutableStringRef itself)
+{
+ CFMutableStringRefObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(CFMutableStringRefObject, &CFMutableStringRef_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_freeit = CFRelease;
+ return (PyObject *)it;
+}
+CFMutableStringRefObj_Convert(PyObject *v, CFMutableStringRef *p_itself)
+{
+
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ /* Check for other CF objects here */
+
+ if (!CFMutableStringRefObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "CFMutableStringRef required");
+ return 0;
+ }
+ *p_itself = ((CFMutableStringRefObject *)v)->ob_itself;
+ return 1;
+}
+
+static void CFMutableStringRefObj_dealloc(CFMutableStringRefObject *self)
+{
+ if (self->ob_freeit && self->ob_itself)
+ {
+ self->ob_freeit((CFTypeRef)self->ob_itself);
+ }
+ PyMem_DEL(self);
+}
+
+static PyObject *CFMutableStringRefObj_CFStringAppend(CFMutableStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef appendedString;
+ PyMac_PRECHECK(CFStringAppend);
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &appendedString))
+ return NULL;
+ CFStringAppend(_self->ob_itself,
+ appendedString);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFMutableStringRefObj_CFStringAppendPascalString(CFMutableStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ StringPtr pStr;
+ CFStringEncoding encoding;
+ PyMac_PRECHECK(CFStringAppendPascalString);
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetStr255, &pStr,
+ &encoding))
+ return NULL;
+ CFStringAppendPascalString(_self->ob_itself,
+ pStr,
+ encoding);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFMutableStringRefObj_CFStringAppendCString(CFMutableStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ char* cStr;
+ CFStringEncoding encoding;
+ PyMac_PRECHECK(CFStringAppendCString);
+ if (!PyArg_ParseTuple(_args, "sl",
+ &cStr,
+ &encoding))
+ return NULL;
+ CFStringAppendCString(_self->ob_itself,
+ cStr,
+ encoding);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFMutableStringRefObj_CFStringInsert(CFMutableStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFIndex idx;
+ CFStringRef insertedStr;
+ PyMac_PRECHECK(CFStringInsert);
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &idx,
+ CFStringRefObj_Convert, &insertedStr))
+ return NULL;
+ CFStringInsert(_self->ob_itself,
+ idx,
+ insertedStr);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFMutableStringRefObj_CFStringDelete(CFMutableStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFRange range;
+ PyMac_PRECHECK(CFStringDelete);
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFRange_Convert, &range))
+ return NULL;
+ CFStringDelete(_self->ob_itself,
+ range);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFMutableStringRefObj_CFStringReplace(CFMutableStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFRange range;
+ CFStringRef replacement;
+ PyMac_PRECHECK(CFStringReplace);
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ CFRange_Convert, &range,
+ CFStringRefObj_Convert, &replacement))
+ return NULL;
+ CFStringReplace(_self->ob_itself,
+ range,
+ replacement);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFMutableStringRefObj_CFStringReplaceAll(CFMutableStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef replacement;
+ PyMac_PRECHECK(CFStringReplaceAll);
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &replacement))
+ return NULL;
+ CFStringReplaceAll(_self->ob_itself,
+ replacement);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFMutableStringRefObj_CFStringPad(CFMutableStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef padString;
+ CFIndex length;
+ CFIndex indexIntoPad;
+ PyMac_PRECHECK(CFStringPad);
+ if (!PyArg_ParseTuple(_args, "O&ll",
+ CFStringRefObj_Convert, &padString,
+ &length,
+ &indexIntoPad))
+ return NULL;
+ CFStringPad(_self->ob_itself,
+ padString,
+ length,
+ indexIntoPad);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFMutableStringRefObj_CFStringTrim(CFMutableStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef trimString;
+ PyMac_PRECHECK(CFStringTrim);
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &trimString))
+ return NULL;
+ CFStringTrim(_self->ob_itself,
+ trimString);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CFMutableStringRefObj_CFStringTrimWhitespace(CFMutableStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyMac_PRECHECK(CFStringTrimWhitespace);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ CFStringTrimWhitespace(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef CFMutableStringRefObj_methods[] = {
+ {"CFStringAppend", (PyCFunction)CFMutableStringRefObj_CFStringAppend, 1,
+ "(CFStringRef appendedString) -> None"},
+ {"CFStringAppendPascalString", (PyCFunction)CFMutableStringRefObj_CFStringAppendPascalString, 1,
+ "(StringPtr pStr, CFStringEncoding encoding) -> None"},
+ {"CFStringAppendCString", (PyCFunction)CFMutableStringRefObj_CFStringAppendCString, 1,
+ "(char* cStr, CFStringEncoding encoding) -> None"},
+ {"CFStringInsert", (PyCFunction)CFMutableStringRefObj_CFStringInsert, 1,
+ "(CFIndex idx, CFStringRef insertedStr) -> None"},
+ {"CFStringDelete", (PyCFunction)CFMutableStringRefObj_CFStringDelete, 1,
+ "(CFRange range) -> None"},
+ {"CFStringReplace", (PyCFunction)CFMutableStringRefObj_CFStringReplace, 1,
+ "(CFRange range, CFStringRef replacement) -> None"},
+ {"CFStringReplaceAll", (PyCFunction)CFMutableStringRefObj_CFStringReplaceAll, 1,
+ "(CFStringRef replacement) -> None"},
+ {"CFStringPad", (PyCFunction)CFMutableStringRefObj_CFStringPad, 1,
+ "(CFStringRef padString, CFIndex length, CFIndex indexIntoPad) -> None"},
+ {"CFStringTrim", (PyCFunction)CFMutableStringRefObj_CFStringTrim, 1,
+ "(CFStringRef trimString) -> None"},
+ {"CFStringTrimWhitespace", (PyCFunction)CFMutableStringRefObj_CFStringTrimWhitespace, 1,
+ "() -> None"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain CFMutableStringRefObj_chain = { CFMutableStringRefObj_methods, &CFStringRefObj_chain };
+
+static PyObject *CFMutableStringRefObj_getattr(CFMutableStringRefObject *self, char *name)
+{
+ return Py_FindMethodInChain(&CFMutableStringRefObj_chain, (PyObject *)self, name);
+}
+
+#define CFMutableStringRefObj_setattr NULL
+
+static int CFMutableStringRefObj_compare(CFMutableStringRefObject *self, CFMutableStringRefObject *other)
+{
+ /* XXXX Or should we use CFEqual?? */
+ if ( self->ob_itself > other->ob_itself ) return 1;
+ if ( self->ob_itself < other->ob_itself ) return -1;
+ return 0;
+}
+
+static PyObject * CFMutableStringRefObj_repr(CFMutableStringRefObject *self)
+{
+ char buf[100];
+ sprintf(buf, "<CFMutableStringRef object at 0x%08.8x for 0x%08.8x>", self, self->ob_itself);
+ return PyString_FromString(buf);
+}
+
+static int CFMutableStringRefObj_hash(CFMutableStringRefObject *self)
+{
+ /* XXXX Or should we use CFHash?? */
+ return (int)self->ob_itself;
+}
+
+PyTypeObject CFMutableStringRef_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "CFMutableStringRef", /*tp_name*/
+ sizeof(CFMutableStringRefObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) CFMutableStringRefObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) CFMutableStringRefObj_getattr, /*tp_getattr*/
+ (setattrfunc) CFMutableStringRefObj_setattr, /*tp_setattr*/
+ (cmpfunc) CFMutableStringRefObj_compare, /*tp_compare*/
+ (reprfunc) CFMutableStringRefObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) CFMutableStringRefObj_hash, /*tp_hash*/
+};
+
+/* --------------- End object type CFMutableStringRef --------------- */
+
+
+/* ---------------------- Object type CFURLRef ---------------------- */
+
+PyTypeObject CFURLRef_Type;
+
+#define CFURLRefObj_Check(x) ((x)->ob_type == &CFURLRef_Type)
+
+typedef struct CFURLRefObject {
+ PyObject_HEAD
+ CFURLRef ob_itself;
+ void (*ob_freeit)(CFTypeRef ptr);
+} CFURLRefObject;
+
+PyObject *CFURLRefObj_New(CFURLRef itself)
+{
+ CFURLRefObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(CFURLRefObject, &CFURLRef_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_freeit = CFRelease;
+ return (PyObject *)it;
+}
+CFURLRefObj_Convert(PyObject *v, CFURLRef *p_itself)
+{
+
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ /* Check for other CF objects here */
+
+ if (!CFURLRefObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "CFURLRef required");
+ return 0;
+ }
+ *p_itself = ((CFURLRefObject *)v)->ob_itself;
+ return 1;
+}
+
+static void CFURLRefObj_dealloc(CFURLRefObject *self)
+{
+ if (self->ob_freeit && self->ob_itself)
+ {
+ self->ob_freeit((CFTypeRef)self->ob_itself);
+ }
+ PyMem_DEL(self);
+}
+
+static PyObject *CFURLRefObj_CFURLCreateData(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFDataRef _rv;
+ CFStringEncoding encoding;
+ Boolean escapeWhitespace;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &encoding,
+ &escapeWhitespace))
+ return NULL;
+ _rv = CFURLCreateData((CFAllocatorRef)NULL,
+ _self->ob_itself,
+ encoding,
+ escapeWhitespace);
+ _res = Py_BuildValue("O&",
+ CFDataRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCopyAbsoluteURL(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFURLRef _rv;
+ PyMac_PRECHECK(CFURLCopyAbsoluteURL);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLCopyAbsoluteURL(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFURLRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLGetString(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ PyMac_PRECHECK(CFURLGetString);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLGetString(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLGetBaseURL(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFURLRef _rv;
+ PyMac_PRECHECK(CFURLGetBaseURL);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLGetBaseURL(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFURLRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCanBeDecomposed(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ PyMac_PRECHECK(CFURLCanBeDecomposed);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLCanBeDecomposed(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCopyScheme(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ PyMac_PRECHECK(CFURLCopyScheme);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLCopyScheme(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCopyNetLocation(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ PyMac_PRECHECK(CFURLCopyNetLocation);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLCopyNetLocation(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCopyPath(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ PyMac_PRECHECK(CFURLCopyPath);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLCopyPath(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLHasDirectoryPath(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ PyMac_PRECHECK(CFURLHasDirectoryPath);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLHasDirectoryPath(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCopyResourceSpecifier(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ PyMac_PRECHECK(CFURLCopyResourceSpecifier);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLCopyResourceSpecifier(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCopyHostName(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ PyMac_PRECHECK(CFURLCopyHostName);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLCopyHostName(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLGetPortNumber(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 _rv;
+ PyMac_PRECHECK(CFURLGetPortNumber);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLGetPortNumber(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCopyUserName(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ PyMac_PRECHECK(CFURLCopyUserName);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLCopyUserName(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCopyPassword(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ PyMac_PRECHECK(CFURLCopyPassword);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLCopyPassword(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCopyParameterString(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ CFStringRef charactersToLeaveEscaped;
+ PyMac_PRECHECK(CFURLCopyParameterString);
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &charactersToLeaveEscaped))
+ return NULL;
+ _rv = CFURLCopyParameterString(_self->ob_itself,
+ charactersToLeaveEscaped);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCopyQueryString(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ CFStringRef charactersToLeaveEscaped;
+ PyMac_PRECHECK(CFURLCopyQueryString);
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &charactersToLeaveEscaped))
+ return NULL;
+ _rv = CFURLCopyQueryString(_self->ob_itself,
+ charactersToLeaveEscaped);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCopyFragment(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ CFStringRef charactersToLeaveEscaped;
+ PyMac_PRECHECK(CFURLCopyFragment);
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &charactersToLeaveEscaped))
+ return NULL;
+ _rv = CFURLCopyFragment(_self->ob_itself,
+ charactersToLeaveEscaped);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyMethodDef CFURLRefObj_methods[] = {
+ {"CFURLCreateData", (PyCFunction)CFURLRefObj_CFURLCreateData, 1,
+ "(CFStringEncoding encoding, Boolean escapeWhitespace) -> (CFDataRef _rv)"},
+ {"CFURLCopyAbsoluteURL", (PyCFunction)CFURLRefObj_CFURLCopyAbsoluteURL, 1,
+ "() -> (CFURLRef _rv)"},
+ {"CFURLGetString", (PyCFunction)CFURLRefObj_CFURLGetString, 1,
+ "() -> (CFStringRef _rv)"},
+ {"CFURLGetBaseURL", (PyCFunction)CFURLRefObj_CFURLGetBaseURL, 1,
+ "() -> (CFURLRef _rv)"},
+ {"CFURLCanBeDecomposed", (PyCFunction)CFURLRefObj_CFURLCanBeDecomposed, 1,
+ "() -> (Boolean _rv)"},
+ {"CFURLCopyScheme", (PyCFunction)CFURLRefObj_CFURLCopyScheme, 1,
+ "() -> (CFStringRef _rv)"},
+ {"CFURLCopyNetLocation", (PyCFunction)CFURLRefObj_CFURLCopyNetLocation, 1,
+ "() -> (CFStringRef _rv)"},
+ {"CFURLCopyPath", (PyCFunction)CFURLRefObj_CFURLCopyPath, 1,
+ "() -> (CFStringRef _rv)"},
+ {"CFURLHasDirectoryPath", (PyCFunction)CFURLRefObj_CFURLHasDirectoryPath, 1,
+ "() -> (Boolean _rv)"},
+ {"CFURLCopyResourceSpecifier", (PyCFunction)CFURLRefObj_CFURLCopyResourceSpecifier, 1,
+ "() -> (CFStringRef _rv)"},
+ {"CFURLCopyHostName", (PyCFunction)CFURLRefObj_CFURLCopyHostName, 1,
+ "() -> (CFStringRef _rv)"},
+ {"CFURLGetPortNumber", (PyCFunction)CFURLRefObj_CFURLGetPortNumber, 1,
+ "() -> (SInt32 _rv)"},
+ {"CFURLCopyUserName", (PyCFunction)CFURLRefObj_CFURLCopyUserName, 1,
+ "() -> (CFStringRef _rv)"},
+ {"CFURLCopyPassword", (PyCFunction)CFURLRefObj_CFURLCopyPassword, 1,
+ "() -> (CFStringRef _rv)"},
+ {"CFURLCopyParameterString", (PyCFunction)CFURLRefObj_CFURLCopyParameterString, 1,
+ "(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
+ {"CFURLCopyQueryString", (PyCFunction)CFURLRefObj_CFURLCopyQueryString, 1,
+ "(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
+ {"CFURLCopyFragment", (PyCFunction)CFURLRefObj_CFURLCopyFragment, 1,
+ "(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain CFURLRefObj_chain = { CFURLRefObj_methods, &CFTypeRefObj_chain };
+
+static PyObject *CFURLRefObj_getattr(CFURLRefObject *self, char *name)
+{
+ return Py_FindMethodInChain(&CFURLRefObj_chain, (PyObject *)self, name);
+}
+
+#define CFURLRefObj_setattr NULL
+
+static int CFURLRefObj_compare(CFURLRefObject *self, CFURLRefObject *other)
+{
+ /* XXXX Or should we use CFEqual?? */
+ if ( self->ob_itself > other->ob_itself ) return 1;
+ if ( self->ob_itself < other->ob_itself ) return -1;
+ return 0;
+}
+
+static PyObject * CFURLRefObj_repr(CFURLRefObject *self)
+{
+ char buf[100];
+ sprintf(buf, "<CFURL object at 0x%08.8x for 0x%08.8x>", self, self->ob_itself);
+ return PyString_FromString(buf);
+}
+
+static int CFURLRefObj_hash(CFURLRefObject *self)
+{
+ /* XXXX Or should we use CFHash?? */
+ return (int)self->ob_itself;
+}
+
+PyTypeObject CFURLRef_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "CFURLRef", /*tp_name*/
+ sizeof(CFURLRefObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) CFURLRefObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) CFURLRefObj_getattr, /*tp_getattr*/
+ (setattrfunc) CFURLRefObj_setattr, /*tp_setattr*/
+ (cmpfunc) CFURLRefObj_compare, /*tp_compare*/
+ (reprfunc) CFURLRefObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) CFURLRefObj_hash, /*tp_hash*/
+};
+
+/* -------------------- End object type CFURLRef -------------------- */
+
+
+static PyObject *CF_CFAllocatorGetTypeID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFTypeID _rv;
+ PyMac_PRECHECK(CFAllocatorGetTypeID);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFAllocatorGetTypeID();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CF_CFAllocatorGetPreferredSizeForSize(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFIndex _rv;
+ CFIndex size;
+ CFOptionFlags hint;
+ PyMac_PRECHECK(CFAllocatorGetPreferredSizeForSize);
+ if (!PyArg_ParseTuple(_args, "ll",
+ &size,
+ &hint))
+ return NULL;
+ _rv = CFAllocatorGetPreferredSizeForSize((CFAllocatorRef)NULL,
+ size,
+ hint);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CF_CFCopyTypeIDDescription(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ CFTypeID theType;
+ PyMac_PRECHECK(CFCopyTypeIDDescription);
+ if (!PyArg_ParseTuple(_args, "l",
+ &theType))
+ return NULL;
+ _rv = CFCopyTypeIDDescription(theType);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFArrayGetTypeID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFTypeID _rv;
+ PyMac_PRECHECK(CFArrayGetTypeID);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFArrayGetTypeID();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CF_CFArrayCreateMutable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFMutableArrayRef _rv;
+ CFIndex capacity;
+ PyMac_PRECHECK(CFArrayCreateMutable);
+ if (!PyArg_ParseTuple(_args, "l",
+ &capacity))
+ return NULL;
+ _rv = CFArrayCreateMutable((CFAllocatorRef)NULL,
+ capacity,
+ &kCFTypeArrayCallBacks);
+ _res = Py_BuildValue("O&",
+ CFMutableArrayRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFArrayCreateMutableCopy(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFMutableArrayRef _rv;
+ CFIndex capacity;
+ CFArrayRef srcArray;
+ PyMac_PRECHECK(CFArrayCreateMutableCopy);
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &capacity,
+ CFArrayRefObj_Convert, &srcArray))
+ return NULL;
+ _rv = CFArrayCreateMutableCopy((CFAllocatorRef)NULL,
+ capacity,
+ srcArray);
+ _res = Py_BuildValue("O&",
+ CFMutableArrayRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFDataGetTypeID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFTypeID _rv;
+ PyMac_PRECHECK(CFDataGetTypeID);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFDataGetTypeID();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CF_CFDataCreate(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFDataRef _rv;
+ unsigned char *bytes__in__;
+ long bytes__len__;
+ int bytes__in_len__;
+ PyMac_PRECHECK(CFDataCreate);
+ if (!PyArg_ParseTuple(_args, "s#",
+ &bytes__in__, &bytes__in_len__))
+ return NULL;
+ bytes__len__ = bytes__in_len__;
+ _rv = CFDataCreate((CFAllocatorRef)NULL,
+ bytes__in__, bytes__len__);
+ _res = Py_BuildValue("O&",
+ CFDataRefObj_New, _rv);
+ bytes__error__: ;
+ return _res;
+}
+
+static PyObject *CF_CFDataCreateWithBytesNoCopy(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFDataRef _rv;
+ unsigned char *bytes__in__;
+ long bytes__len__;
+ int bytes__in_len__;
+ PyMac_PRECHECK(CFDataCreateWithBytesNoCopy);
+ if (!PyArg_ParseTuple(_args, "s#",
+ &bytes__in__, &bytes__in_len__))
+ return NULL;
+ bytes__len__ = bytes__in_len__;
+ _rv = CFDataCreateWithBytesNoCopy((CFAllocatorRef)NULL,
+ bytes__in__, bytes__len__,
+ (CFAllocatorRef)NULL);
+ _res = Py_BuildValue("O&",
+ CFDataRefObj_New, _rv);
+ bytes__error__: ;
+ return _res;
+}
+
+static PyObject *CF_CFDataCreateMutable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFMutableDataRef _rv;
+ CFIndex capacity;
+ PyMac_PRECHECK(CFDataCreateMutable);
+ if (!PyArg_ParseTuple(_args, "l",
+ &capacity))
+ return NULL;
+ _rv = CFDataCreateMutable((CFAllocatorRef)NULL,
+ capacity);
+ _res = Py_BuildValue("O&",
+ CFMutableDataRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFDataCreateMutableCopy(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFMutableDataRef _rv;
+ CFIndex capacity;
+ CFDataRef data;
+ PyMac_PRECHECK(CFDataCreateMutableCopy);
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &capacity,
+ CFDataRefObj_Convert, &data))
+ return NULL;
+ _rv = CFDataCreateMutableCopy((CFAllocatorRef)NULL,
+ capacity,
+ data);
+ _res = Py_BuildValue("O&",
+ CFMutableDataRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFDictionaryGetTypeID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFTypeID _rv;
+ PyMac_PRECHECK(CFDictionaryGetTypeID);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFDictionaryGetTypeID();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CF_CFDictionaryCreateMutable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFMutableDictionaryRef _rv;
+ CFIndex capacity;
+ PyMac_PRECHECK(CFDictionaryCreateMutable);
+ if (!PyArg_ParseTuple(_args, "l",
+ &capacity))
+ return NULL;
+ _rv = CFDictionaryCreateMutable((CFAllocatorRef)NULL,
+ capacity,
+ &kCFTypeDictionaryKeyCallBacks,
+ &kCFTypeDictionaryValueCallBacks);
+ _res = Py_BuildValue("O&",
+ CFMutableDictionaryRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFDictionaryCreateMutableCopy(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFMutableDictionaryRef _rv;
+ CFIndex capacity;
+ CFDictionaryRef dict;
+ PyMac_PRECHECK(CFDictionaryCreateMutableCopy);
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &capacity,
+ CFDictionaryRefObj_Convert, &dict))
+ return NULL;
+ _rv = CFDictionaryCreateMutableCopy((CFAllocatorRef)NULL,
+ capacity,
+ dict);
+ _res = Py_BuildValue("O&",
+ CFMutableDictionaryRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringGetTypeID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFTypeID _rv;
+ PyMac_PRECHECK(CFStringGetTypeID);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFStringGetTypeID();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringCreateWithPascalString(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ StringPtr pStr;
+ CFStringEncoding encoding;
+ PyMac_PRECHECK(CFStringCreateWithPascalString);
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetStr255, &pStr,
+ &encoding))
+ return NULL;
+ _rv = CFStringCreateWithPascalString((CFAllocatorRef)NULL,
+ pStr,
+ encoding);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringCreateWithCString(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ char* cStr;
+ CFStringEncoding encoding;
+ PyMac_PRECHECK(CFStringCreateWithCString);
+ if (!PyArg_ParseTuple(_args, "sl",
+ &cStr,
+ &encoding))
+ return NULL;
+ _rv = CFStringCreateWithCString((CFAllocatorRef)NULL,
+ cStr,
+ encoding);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringCreateWithPascalStringNoCopy(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ StringPtr pStr;
+ CFStringEncoding encoding;
+ PyMac_PRECHECK(CFStringCreateWithPascalStringNoCopy);
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetStr255, &pStr,
+ &encoding))
+ return NULL;
+ _rv = CFStringCreateWithPascalStringNoCopy((CFAllocatorRef)NULL,
+ pStr,
+ encoding,
+ (CFAllocatorRef)NULL);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringCreateWithCStringNoCopy(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ char* cStr;
+ CFStringEncoding encoding;
+ PyMac_PRECHECK(CFStringCreateWithCStringNoCopy);
+ if (!PyArg_ParseTuple(_args, "sl",
+ &cStr,
+ &encoding))
+ return NULL;
+ _rv = CFStringCreateWithCStringNoCopy((CFAllocatorRef)NULL,
+ cStr,
+ encoding,
+ (CFAllocatorRef)NULL);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringCreateMutable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFMutableStringRef _rv;
+ CFIndex maxLength;
+ PyMac_PRECHECK(CFStringCreateMutable);
+ if (!PyArg_ParseTuple(_args, "l",
+ &maxLength))
+ return NULL;
+ _rv = CFStringCreateMutable((CFAllocatorRef)NULL,
+ maxLength);
+ _res = Py_BuildValue("O&",
+ CFMutableStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringCreateMutableCopy(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFMutableStringRef _rv;
+ CFIndex maxLength;
+ CFStringRef theString;
+ PyMac_PRECHECK(CFStringCreateMutableCopy);
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &maxLength,
+ CFStringRefObj_Convert, &theString))
+ return NULL;
+ _rv = CFStringCreateMutableCopy((CFAllocatorRef)NULL,
+ maxLength,
+ theString);
+ _res = Py_BuildValue("O&",
+ CFMutableStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringCreateWithBytes(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ unsigned char *bytes__in__;
+ long bytes__len__;
+ int bytes__in_len__;
+ CFStringEncoding encoding;
+ Boolean isExternalRepresentation;
+ PyMac_PRECHECK(CFStringCreateWithBytes);
+ if (!PyArg_ParseTuple(_args, "s#ll",
+ &bytes__in__, &bytes__in_len__,
+ &encoding,
+ &isExternalRepresentation))
+ return NULL;
+ bytes__len__ = bytes__in_len__;
+ _rv = CFStringCreateWithBytes((CFAllocatorRef)NULL,
+ bytes__in__, bytes__len__,
+ encoding,
+ isExternalRepresentation);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ bytes__error__: ;
+ return _res;
+}
+
+static PyObject *CF_CFStringGetSystemEncoding(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringEncoding _rv;
+ PyMac_PRECHECK(CFStringGetSystemEncoding);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFStringGetSystemEncoding();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringGetMaximumSizeForEncoding(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFIndex _rv;
+ CFIndex length;
+ CFStringEncoding encoding;
+ PyMac_PRECHECK(CFStringGetMaximumSizeForEncoding);
+ if (!PyArg_ParseTuple(_args, "ll",
+ &length,
+ &encoding))
+ return NULL;
+ _rv = CFStringGetMaximumSizeForEncoding(length,
+ encoding);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringIsEncodingAvailable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ CFStringEncoding encoding;
+ PyMac_PRECHECK(CFStringIsEncodingAvailable);
+ if (!PyArg_ParseTuple(_args, "l",
+ &encoding))
+ return NULL;
+ _rv = CFStringIsEncodingAvailable(encoding);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringGetNameOfEncoding(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ CFStringEncoding encoding;
+ PyMac_PRECHECK(CFStringGetNameOfEncoding);
+ if (!PyArg_ParseTuple(_args, "l",
+ &encoding))
+ return NULL;
+ _rv = CFStringGetNameOfEncoding(encoding);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringConvertEncodingToNSStringEncoding(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt32 _rv;
+ CFStringEncoding encoding;
+ PyMac_PRECHECK(CFStringConvertEncodingToNSStringEncoding);
+ if (!PyArg_ParseTuple(_args, "l",
+ &encoding))
+ return NULL;
+ _rv = CFStringConvertEncodingToNSStringEncoding(encoding);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringConvertNSStringEncodingToEncoding(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringEncoding _rv;
+ UInt32 encoding;
+ PyMac_PRECHECK(CFStringConvertNSStringEncodingToEncoding);
+ if (!PyArg_ParseTuple(_args, "l",
+ &encoding))
+ return NULL;
+ _rv = CFStringConvertNSStringEncodingToEncoding(encoding);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringConvertEncodingToWindowsCodepage(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt32 _rv;
+ CFStringEncoding encoding;
+ PyMac_PRECHECK(CFStringConvertEncodingToWindowsCodepage);
+ if (!PyArg_ParseTuple(_args, "l",
+ &encoding))
+ return NULL;
+ _rv = CFStringConvertEncodingToWindowsCodepage(encoding);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringConvertWindowsCodepageToEncoding(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringEncoding _rv;
+ UInt32 codepage;
+ PyMac_PRECHECK(CFStringConvertWindowsCodepageToEncoding);
+ if (!PyArg_ParseTuple(_args, "l",
+ &codepage))
+ return NULL;
+ _rv = CFStringConvertWindowsCodepageToEncoding(codepage);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CF_CFStringConvertEncodingToIANACharSetName(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ CFStringEncoding encoding;
+ PyMac_PRECHECK(CFStringConvertEncodingToIANACharSetName);
+ if (!PyArg_ParseTuple(_args, "l",
+ &encoding))
+ return NULL;
+ _rv = CFStringConvertEncodingToIANACharSetName(encoding);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF___CFStringMakeConstantString(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ char* cStr;
+ PyMac_PRECHECK(__CFStringMakeConstantString);
+ if (!PyArg_ParseTuple(_args, "s",
+ &cStr))
+ return NULL;
+ _rv = __CFStringMakeConstantString(cStr);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFURLGetTypeID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFTypeID _rv;
+ PyMac_PRECHECK(CFURLGetTypeID);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLGetTypeID();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CF_CFURLCreateWithBytes(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFURLRef _rv;
+ unsigned char *URLBytes__in__;
+ long URLBytes__len__;
+ int URLBytes__in_len__;
+ CFStringEncoding encoding;
+ CFURLRef baseURL;
+ PyMac_PRECHECK(CFURLCreateWithBytes);
+ if (!PyArg_ParseTuple(_args, "s#lO&",
+ &URLBytes__in__, &URLBytes__in_len__,
+ &encoding,
+ OptionalCFURLRefObj_Convert, &baseURL))
+ return NULL;
+ URLBytes__len__ = URLBytes__in_len__;
+ _rv = CFURLCreateWithBytes((CFAllocatorRef)NULL,
+ URLBytes__in__, URLBytes__len__,
+ encoding,
+ baseURL);
+ _res = Py_BuildValue("O&",
+ CFURLRefObj_New, _rv);
+ URLBytes__error__: ;
+ return _res;
+}
+
+static PyMethodDef CF_methods[] = {
+ {"CFAllocatorGetTypeID", (PyCFunction)CF_CFAllocatorGetTypeID, 1,
+ "() -> (CFTypeID _rv)"},
+ {"CFAllocatorGetPreferredSizeForSize", (PyCFunction)CF_CFAllocatorGetPreferredSizeForSize, 1,
+ "(CFIndex size, CFOptionFlags hint) -> (CFIndex _rv)"},
+ {"CFCopyTypeIDDescription", (PyCFunction)CF_CFCopyTypeIDDescription, 1,
+ "(CFTypeID theType) -> (CFStringRef _rv)"},
+ {"CFArrayGetTypeID", (PyCFunction)CF_CFArrayGetTypeID, 1,
+ "() -> (CFTypeID _rv)"},
+ {"CFArrayCreateMutable", (PyCFunction)CF_CFArrayCreateMutable, 1,
+ "(CFIndex capacity) -> (CFMutableArrayRef _rv)"},
+ {"CFArrayCreateMutableCopy", (PyCFunction)CF_CFArrayCreateMutableCopy, 1,
+ "(CFIndex capacity, CFArrayRef srcArray) -> (CFMutableArrayRef _rv)"},
+ {"CFDataGetTypeID", (PyCFunction)CF_CFDataGetTypeID, 1,
+ "() -> (CFTypeID _rv)"},
+ {"CFDataCreate", (PyCFunction)CF_CFDataCreate, 1,
+ "(Buffer bytes) -> (CFDataRef _rv)"},
+ {"CFDataCreateWithBytesNoCopy", (PyCFunction)CF_CFDataCreateWithBytesNoCopy, 1,
+ "(Buffer bytes) -> (CFDataRef _rv)"},
+ {"CFDataCreateMutable", (PyCFunction)CF_CFDataCreateMutable, 1,
+ "(CFIndex capacity) -> (CFMutableDataRef _rv)"},
+ {"CFDataCreateMutableCopy", (PyCFunction)CF_CFDataCreateMutableCopy, 1,
+ "(CFIndex capacity, CFDataRef data) -> (CFMutableDataRef _rv)"},
+ {"CFDictionaryGetTypeID", (PyCFunction)CF_CFDictionaryGetTypeID, 1,
+ "() -> (CFTypeID _rv)"},
+ {"CFDictionaryCreateMutable", (PyCFunction)CF_CFDictionaryCreateMutable, 1,
+ "(CFIndex capacity) -> (CFMutableDictionaryRef _rv)"},
+ {"CFDictionaryCreateMutableCopy", (PyCFunction)CF_CFDictionaryCreateMutableCopy, 1,
+ "(CFIndex capacity, CFDictionaryRef dict) -> (CFMutableDictionaryRef _rv)"},
+ {"CFStringGetTypeID", (PyCFunction)CF_CFStringGetTypeID, 1,
+ "() -> (CFTypeID _rv)"},
+ {"CFStringCreateWithPascalString", (PyCFunction)CF_CFStringCreateWithPascalString, 1,
+ "(StringPtr pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
+ {"CFStringCreateWithCString", (PyCFunction)CF_CFStringCreateWithCString, 1,
+ "(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
+ {"CFStringCreateWithPascalStringNoCopy", (PyCFunction)CF_CFStringCreateWithPascalStringNoCopy, 1,
+ "(StringPtr pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
+ {"CFStringCreateWithCStringNoCopy", (PyCFunction)CF_CFStringCreateWithCStringNoCopy, 1,
+ "(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
+ {"CFStringCreateMutable", (PyCFunction)CF_CFStringCreateMutable, 1,
+ "(CFIndex maxLength) -> (CFMutableStringRef _rv)"},
+ {"CFStringCreateMutableCopy", (PyCFunction)CF_CFStringCreateMutableCopy, 1,
+ "(CFIndex maxLength, CFStringRef theString) -> (CFMutableStringRef _rv)"},
+ {"CFStringCreateWithBytes", (PyCFunction)CF_CFStringCreateWithBytes, 1,
+ "(Buffer bytes, CFStringEncoding encoding, Boolean isExternalRepresentation) -> (CFStringRef _rv)"},
+ {"CFStringGetSystemEncoding", (PyCFunction)CF_CFStringGetSystemEncoding, 1,
+ "() -> (CFStringEncoding _rv)"},
+ {"CFStringGetMaximumSizeForEncoding", (PyCFunction)CF_CFStringGetMaximumSizeForEncoding, 1,
+ "(CFIndex length, CFStringEncoding encoding) -> (CFIndex _rv)"},
+ {"CFStringIsEncodingAvailable", (PyCFunction)CF_CFStringIsEncodingAvailable, 1,
+ "(CFStringEncoding encoding) -> (Boolean _rv)"},
+ {"CFStringGetNameOfEncoding", (PyCFunction)CF_CFStringGetNameOfEncoding, 1,
+ "(CFStringEncoding encoding) -> (CFStringRef _rv)"},
+ {"CFStringConvertEncodingToNSStringEncoding", (PyCFunction)CF_CFStringConvertEncodingToNSStringEncoding, 1,
+ "(CFStringEncoding encoding) -> (UInt32 _rv)"},
+ {"CFStringConvertNSStringEncodingToEncoding", (PyCFunction)CF_CFStringConvertNSStringEncodingToEncoding, 1,
+ "(UInt32 encoding) -> (CFStringEncoding _rv)"},
+ {"CFStringConvertEncodingToWindowsCodepage", (PyCFunction)CF_CFStringConvertEncodingToWindowsCodepage, 1,
+ "(CFStringEncoding encoding) -> (UInt32 _rv)"},
+ {"CFStringConvertWindowsCodepageToEncoding", (PyCFunction)CF_CFStringConvertWindowsCodepageToEncoding, 1,
+ "(UInt32 codepage) -> (CFStringEncoding _rv)"},
+ {"CFStringConvertEncodingToIANACharSetName", (PyCFunction)CF_CFStringConvertEncodingToIANACharSetName, 1,
+ "(CFStringEncoding encoding) -> (CFStringRef _rv)"},
+ {"__CFStringMakeConstantString", (PyCFunction)CF___CFStringMakeConstantString, 1,
+ "(char* cStr) -> (CFStringRef _rv)"},
+ {"CFURLGetTypeID", (PyCFunction)CF_CFURLGetTypeID, 1,
+ "() -> (CFTypeID _rv)"},
+ {"CFURLCreateWithBytes", (PyCFunction)CF_CFURLCreateWithBytes, 1,
+ "(Buffer URLBytes, CFStringEncoding encoding, CFURLRef baseURL) -> (CFURLRef _rv)"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_CF(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ // PyMac_INIT_TOOLBOX_OBJECT_NEW(Track, TrackObj_New);
+ // PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Track, TrackObj_Convert);
+
+
+ m = Py_InitModule("_CF", CF_methods);
+ d = PyModule_GetDict(m);
+ CF_Error = PyMac_GetOSErrException();
+ if (CF_Error == NULL ||
+ PyDict_SetItemString(d, "Error", CF_Error) != 0)
+ return;
+ CFTypeRef_Type.ob_type = &PyType_Type;
+ Py_INCREF(&CFTypeRef_Type);
+ if (PyDict_SetItemString(d, "CFTypeRefType", (PyObject *)&CFTypeRef_Type) != 0)
+ Py_FatalError("can't initialize CFTypeRefType");
+ CFArrayRef_Type.ob_type = &PyType_Type;
+ Py_INCREF(&CFArrayRef_Type);
+ if (PyDict_SetItemString(d, "CFArrayRefType", (PyObject *)&CFArrayRef_Type) != 0)
+ Py_FatalError("can't initialize CFArrayRefType");
+ CFMutableArrayRef_Type.ob_type = &PyType_Type;
+ Py_INCREF(&CFMutableArrayRef_Type);
+ if (PyDict_SetItemString(d, "CFMutableArrayRefType", (PyObject *)&CFMutableArrayRef_Type) != 0)
+ Py_FatalError("can't initialize CFMutableArrayRefType");
+ CFDictionaryRef_Type.ob_type = &PyType_Type;
+ Py_INCREF(&CFDictionaryRef_Type);
+ if (PyDict_SetItemString(d, "CFDictionaryRefType", (PyObject *)&CFDictionaryRef_Type) != 0)
+ Py_FatalError("can't initialize CFDictionaryRefType");
+ CFMutableDictionaryRef_Type.ob_type = &PyType_Type;
+ Py_INCREF(&CFMutableDictionaryRef_Type);
+ if (PyDict_SetItemString(d, "CFMutableDictionaryRefType", (PyObject *)&CFMutableDictionaryRef_Type) != 0)
+ Py_FatalError("can't initialize CFMutableDictionaryRefType");
+ CFDataRef_Type.ob_type = &PyType_Type;
+ Py_INCREF(&CFDataRef_Type);
+ if (PyDict_SetItemString(d, "CFDataRefType", (PyObject *)&CFDataRef_Type) != 0)
+ Py_FatalError("can't initialize CFDataRefType");
+ CFMutableDataRef_Type.ob_type = &PyType_Type;
+ Py_INCREF(&CFMutableDataRef_Type);
+ if (PyDict_SetItemString(d, "CFMutableDataRefType", (PyObject *)&CFMutableDataRef_Type) != 0)
+ Py_FatalError("can't initialize CFMutableDataRefType");
+ CFStringRef_Type.ob_type = &PyType_Type;
+ Py_INCREF(&CFStringRef_Type);
+ if (PyDict_SetItemString(d, "CFStringRefType", (PyObject *)&CFStringRef_Type) != 0)
+ Py_FatalError("can't initialize CFStringRefType");
+ CFMutableStringRef_Type.ob_type = &PyType_Type;
+ Py_INCREF(&CFMutableStringRef_Type);
+ if (PyDict_SetItemString(d, "CFMutableStringRefType", (PyObject *)&CFMutableStringRef_Type) != 0)
+ Py_FatalError("can't initialize CFMutableStringRefType");
+ CFURLRef_Type.ob_type = &PyType_Type;
+ Py_INCREF(&CFURLRef_Type);
+ if (PyDict_SetItemString(d, "CFURLRefType", (PyObject *)&CFURLRef_Type) != 0)
+ Py_FatalError("can't initialize CFURLRefType");
+}
+
+/* ========================= End module _CF ========================= */
+
--- /dev/null
+
+/* =========================== Module _Cm =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Components.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+extern PyObject *_CmpObj_New(Component);
+extern int _CmpObj_Convert(PyObject *, Component *);
+extern PyObject *_CmpInstObj_New(ComponentInstance);
+extern int _CmpInstObj_Convert(PyObject *, ComponentInstance *);
+
+#define CmpObj_New _CmpObj_New
+#define CmpObj_Convert _CmpObj_Convert
+#define CmpInstObj_New _CmpInstObj_New
+#define CmpInstObj_Convert _CmpInstObj_Convert
+#endif
+
+/*
+** Parse/generate ComponentDescriptor records
+*/
+static PyObject *
+CmpDesc_New(ComponentDescription *itself)
+{
+
+ return Py_BuildValue("O&O&O&ll",
+ PyMac_BuildOSType, itself->componentType,
+ PyMac_BuildOSType, itself->componentSubType,
+ PyMac_BuildOSType, itself->componentManufacturer,
+ itself->componentFlags, itself->componentFlagsMask);
+}
+
+static int
+CmpDesc_Convert(PyObject *v, ComponentDescription *p_itself)
+{
+ return PyArg_ParseTuple(v, "O&O&O&ll",
+ PyMac_GetOSType, &p_itself->componentType,
+ PyMac_GetOSType, &p_itself->componentSubType,
+ PyMac_GetOSType, &p_itself->componentManufacturer,
+ &p_itself->componentFlags, &p_itself->componentFlagsMask);
+}
+
+
+static PyObject *Cm_Error;
+
+/* ----------------- Object type ComponentInstance ------------------ */
+
+PyTypeObject ComponentInstance_Type;
+
+#define CmpInstObj_Check(x) ((x)->ob_type == &ComponentInstance_Type)
+
+typedef struct ComponentInstanceObject {
+ PyObject_HEAD
+ ComponentInstance ob_itself;
+} ComponentInstanceObject;
+
+PyObject *CmpInstObj_New(ComponentInstance itself)
+{
+ ComponentInstanceObject *it;
+ if (itself == NULL) {
+ PyErr_SetString(Cm_Error,"NULL ComponentInstance");
+ return NULL;
+ }
+ it = PyObject_NEW(ComponentInstanceObject, &ComponentInstance_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+CmpInstObj_Convert(PyObject *v, ComponentInstance *p_itself)
+{
+ if (!CmpInstObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "ComponentInstance required");
+ return 0;
+ }
+ *p_itself = ((ComponentInstanceObject *)v)->ob_itself;
+ return 1;
+}
+
+static void CmpInstObj_dealloc(ComponentInstanceObject *self)
+{
+ /* Cleanup of self->ob_itself goes here */
+ PyMem_DEL(self);
+}
+
+static PyObject *CmpInstObj_CloseComponent(ComponentInstanceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = CloseComponent(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CmpInstObj_GetComponentInstanceError(ComponentInstanceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetComponentInstanceError(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CmpInstObj_SetComponentInstanceError(ComponentInstanceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr theError;
+ if (!PyArg_ParseTuple(_args, "h",
+ &theError))
+ return NULL;
+ SetComponentInstanceError(_self->ob_itself,
+ theError);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CmpInstObj_GetComponentInstanceStorage(ComponentInstanceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetComponentInstanceStorage(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CmpInstObj_SetComponentInstanceStorage(ComponentInstanceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle theStorage;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theStorage))
+ return NULL;
+ SetComponentInstanceStorage(_self->ob_itself,
+ theStorage);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *CmpInstObj_GetComponentInstanceA5(ComponentInstanceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetComponentInstanceA5(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *CmpInstObj_SetComponentInstanceA5(ComponentInstanceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long theA5;
+ if (!PyArg_ParseTuple(_args, "l",
+ &theA5))
+ return NULL;
+ SetComponentInstanceA5(_self->ob_itself,
+ theA5);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *CmpInstObj_ComponentFunctionImplemented(ComponentInstanceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ short ftnNumber;
+ if (!PyArg_ParseTuple(_args, "h",
+ &ftnNumber))
+ return NULL;
+ _rv = ComponentFunctionImplemented(_self->ob_itself,
+ ftnNumber);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CmpInstObj_GetComponentVersion(ComponentInstanceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetComponentVersion(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CmpInstObj_ComponentSetTarget(ComponentInstanceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ ComponentInstance target;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &target))
+ return NULL;
+ _rv = ComponentSetTarget(_self->ob_itself,
+ target);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyMethodDef CmpInstObj_methods[] = {
+ {"CloseComponent", (PyCFunction)CmpInstObj_CloseComponent, 1,
+ "() -> None"},
+ {"GetComponentInstanceError", (PyCFunction)CmpInstObj_GetComponentInstanceError, 1,
+ "() -> None"},
+ {"SetComponentInstanceError", (PyCFunction)CmpInstObj_SetComponentInstanceError, 1,
+ "(OSErr theError) -> None"},
+ {"GetComponentInstanceStorage", (PyCFunction)CmpInstObj_GetComponentInstanceStorage, 1,
+ "() -> (Handle _rv)"},
+ {"SetComponentInstanceStorage", (PyCFunction)CmpInstObj_SetComponentInstanceStorage, 1,
+ "(Handle theStorage) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+ {"GetComponentInstanceA5", (PyCFunction)CmpInstObj_GetComponentInstanceA5, 1,
+ "() -> (long _rv)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"SetComponentInstanceA5", (PyCFunction)CmpInstObj_SetComponentInstanceA5, 1,
+ "(long theA5) -> None"},
+#endif
+ {"ComponentFunctionImplemented", (PyCFunction)CmpInstObj_ComponentFunctionImplemented, 1,
+ "(short ftnNumber) -> (long _rv)"},
+ {"GetComponentVersion", (PyCFunction)CmpInstObj_GetComponentVersion, 1,
+ "() -> (long _rv)"},
+ {"ComponentSetTarget", (PyCFunction)CmpInstObj_ComponentSetTarget, 1,
+ "(ComponentInstance target) -> (long _rv)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain CmpInstObj_chain = { CmpInstObj_methods, NULL };
+
+static PyObject *CmpInstObj_getattr(ComponentInstanceObject *self, char *name)
+{
+ return Py_FindMethodInChain(&CmpInstObj_chain, (PyObject *)self, name);
+}
+
+#define CmpInstObj_setattr NULL
+
+#define CmpInstObj_compare NULL
+
+#define CmpInstObj_repr NULL
+
+#define CmpInstObj_hash NULL
+
+PyTypeObject ComponentInstance_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "ComponentInstance", /*tp_name*/
+ sizeof(ComponentInstanceObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) CmpInstObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) CmpInstObj_getattr, /*tp_getattr*/
+ (setattrfunc) CmpInstObj_setattr, /*tp_setattr*/
+ (cmpfunc) CmpInstObj_compare, /*tp_compare*/
+ (reprfunc) CmpInstObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) CmpInstObj_hash, /*tp_hash*/
+};
+
+/* --------------- End object type ComponentInstance ---------------- */
+
+
+/* --------------------- Object type Component ---------------------- */
+
+PyTypeObject Component_Type;
+
+#define CmpObj_Check(x) ((x)->ob_type == &Component_Type)
+
+typedef struct ComponentObject {
+ PyObject_HEAD
+ Component ob_itself;
+} ComponentObject;
+
+PyObject *CmpObj_New(Component itself)
+{
+ ComponentObject *it;
+ if (itself == NULL) {
+ /* XXXX Or should we return None? */
+ PyErr_SetString(Cm_Error,"No such component");
+ return NULL;
+ }
+ it = PyObject_NEW(ComponentObject, &Component_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+CmpObj_Convert(PyObject *v, Component *p_itself)
+{
+ if ( v == Py_None ) {
+ *p_itself = 0;
+ return 1;
+ }
+ if (!CmpObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "Component required");
+ return 0;
+ }
+ *p_itself = ((ComponentObject *)v)->ob_itself;
+ return 1;
+}
+
+static void CmpObj_dealloc(ComponentObject *self)
+{
+ /* Cleanup of self->ob_itself goes here */
+ PyMem_DEL(self);
+}
+
+static PyObject *CmpObj_UnregisterComponent(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = UnregisterComponent(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CmpObj_GetComponentInfo(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ComponentDescription cd;
+ Handle componentName;
+ Handle componentInfo;
+ Handle componentIcon;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ ResObj_Convert, &componentName,
+ ResObj_Convert, &componentInfo,
+ ResObj_Convert, &componentIcon))
+ return NULL;
+ _err = GetComponentInfo(_self->ob_itself,
+ &cd,
+ componentName,
+ componentInfo,
+ componentIcon);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CmpDesc_New, &cd);
+ return _res;
+}
+
+static PyObject *CmpObj_OpenComponent(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentInstance _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = OpenComponent(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CmpInstObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CmpObj_GetComponentRefcon(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetComponentRefcon(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CmpObj_SetComponentRefcon(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long theRefcon;
+ if (!PyArg_ParseTuple(_args, "l",
+ &theRefcon))
+ return NULL;
+ SetComponentRefcon(_self->ob_itself,
+ theRefcon);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CmpObj_OpenComponentResFile(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = OpenComponentResFile(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *CmpObj_GetComponentResource(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType resType;
+ short resID;
+ Handle theResource;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetOSType, &resType,
+ &resID))
+ return NULL;
+ _err = GetComponentResource(_self->ob_itself,
+ resType,
+ resID,
+ &theResource);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, theResource);
+ return _res;
+}
+
+static PyObject *CmpObj_GetComponentIndString(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Str255 theString;
+ short strListID;
+ short index;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetStr255, theString,
+ &strListID,
+ &index))
+ return NULL;
+ _err = GetComponentIndString(_self->ob_itself,
+ theString,
+ strListID,
+ index);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CmpObj_ResolveComponentAlias(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Component _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = ResolveComponentAlias(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CmpObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CmpObj_CountComponentInstances(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CountComponentInstances(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CmpObj_SetDefaultComponent(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short flags;
+ if (!PyArg_ParseTuple(_args, "h",
+ &flags))
+ return NULL;
+ _err = SetDefaultComponent(_self->ob_itself,
+ flags);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CmpObj_CaptureComponent(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Component _rv;
+ Component capturingComponent;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpObj_Convert, &capturingComponent))
+ return NULL;
+ _rv = CaptureComponent(_self->ob_itself,
+ capturingComponent);
+ _res = Py_BuildValue("O&",
+ CmpObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CmpObj_UncaptureComponent(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = UncaptureComponent(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CmpObj_GetComponentIconSuite(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle iconSuite;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetComponentIconSuite(_self->ob_itself,
+ &iconSuite);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, iconSuite);
+ return _res;
+}
+
+static PyMethodDef CmpObj_methods[] = {
+ {"UnregisterComponent", (PyCFunction)CmpObj_UnregisterComponent, 1,
+ "() -> None"},
+ {"GetComponentInfo", (PyCFunction)CmpObj_GetComponentInfo, 1,
+ "(Handle componentName, Handle componentInfo, Handle componentIcon) -> (ComponentDescription cd)"},
+ {"OpenComponent", (PyCFunction)CmpObj_OpenComponent, 1,
+ "() -> (ComponentInstance _rv)"},
+ {"GetComponentRefcon", (PyCFunction)CmpObj_GetComponentRefcon, 1,
+ "() -> (long _rv)"},
+ {"SetComponentRefcon", (PyCFunction)CmpObj_SetComponentRefcon, 1,
+ "(long theRefcon) -> None"},
+ {"OpenComponentResFile", (PyCFunction)CmpObj_OpenComponentResFile, 1,
+ "() -> (short _rv)"},
+ {"GetComponentResource", (PyCFunction)CmpObj_GetComponentResource, 1,
+ "(OSType resType, short resID) -> (Handle theResource)"},
+ {"GetComponentIndString", (PyCFunction)CmpObj_GetComponentIndString, 1,
+ "(Str255 theString, short strListID, short index) -> None"},
+ {"ResolveComponentAlias", (PyCFunction)CmpObj_ResolveComponentAlias, 1,
+ "() -> (Component _rv)"},
+ {"CountComponentInstances", (PyCFunction)CmpObj_CountComponentInstances, 1,
+ "() -> (long _rv)"},
+ {"SetDefaultComponent", (PyCFunction)CmpObj_SetDefaultComponent, 1,
+ "(short flags) -> None"},
+ {"CaptureComponent", (PyCFunction)CmpObj_CaptureComponent, 1,
+ "(Component capturingComponent) -> (Component _rv)"},
+ {"UncaptureComponent", (PyCFunction)CmpObj_UncaptureComponent, 1,
+ "() -> None"},
+ {"GetComponentIconSuite", (PyCFunction)CmpObj_GetComponentIconSuite, 1,
+ "() -> (Handle iconSuite)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain CmpObj_chain = { CmpObj_methods, NULL };
+
+static PyObject *CmpObj_getattr(ComponentObject *self, char *name)
+{
+ return Py_FindMethodInChain(&CmpObj_chain, (PyObject *)self, name);
+}
+
+#define CmpObj_setattr NULL
+
+#define CmpObj_compare NULL
+
+#define CmpObj_repr NULL
+
+#define CmpObj_hash NULL
+
+PyTypeObject Component_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "Component", /*tp_name*/
+ sizeof(ComponentObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) CmpObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) CmpObj_getattr, /*tp_getattr*/
+ (setattrfunc) CmpObj_setattr, /*tp_setattr*/
+ (cmpfunc) CmpObj_compare, /*tp_compare*/
+ (reprfunc) CmpObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) CmpObj_hash, /*tp_hash*/
+};
+
+/* ------------------- End object type Component -------------------- */
+
+
+static PyObject *Cm_RegisterComponentResource(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Component _rv;
+ ComponentResourceHandle cr;
+ short global;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ ResObj_Convert, &cr,
+ &global))
+ return NULL;
+ _rv = RegisterComponentResource(cr,
+ global);
+ _res = Py_BuildValue("O&",
+ CmpObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Cm_FindNextComponent(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Component _rv;
+ Component aComponent;
+ ComponentDescription looking;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ CmpObj_Convert, &aComponent,
+ CmpDesc_Convert, &looking))
+ return NULL;
+ _rv = FindNextComponent(aComponent,
+ &looking);
+ _res = Py_BuildValue("O&",
+ CmpObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Cm_CountComponents(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ ComponentDescription looking;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpDesc_Convert, &looking))
+ return NULL;
+ _rv = CountComponents(&looking);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Cm_GetComponentListModSeed(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetComponentListModSeed();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Cm_CloseComponentResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short refnum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &refnum))
+ return NULL;
+ _err = CloseComponentResFile(refnum);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Cm_OpenDefaultComponent(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentInstance _rv;
+ OSType componentType;
+ OSType componentSubType;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &componentType,
+ PyMac_GetOSType, &componentSubType))
+ return NULL;
+ _rv = OpenDefaultComponent(componentType,
+ componentSubType);
+ _res = Py_BuildValue("O&",
+ CmpInstObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Cm_RegisterComponentResourceFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ short resRefNum;
+ short global;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &resRefNum,
+ &global))
+ return NULL;
+ _rv = RegisterComponentResourceFile(resRefNum,
+ global);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyMethodDef Cm_methods[] = {
+ {"RegisterComponentResource", (PyCFunction)Cm_RegisterComponentResource, 1,
+ "(ComponentResourceHandle cr, short global) -> (Component _rv)"},
+ {"FindNextComponent", (PyCFunction)Cm_FindNextComponent, 1,
+ "(Component aComponent, ComponentDescription looking) -> (Component _rv)"},
+ {"CountComponents", (PyCFunction)Cm_CountComponents, 1,
+ "(ComponentDescription looking) -> (long _rv)"},
+ {"GetComponentListModSeed", (PyCFunction)Cm_GetComponentListModSeed, 1,
+ "() -> (long _rv)"},
+ {"CloseComponentResFile", (PyCFunction)Cm_CloseComponentResFile, 1,
+ "(short refnum) -> None"},
+ {"OpenDefaultComponent", (PyCFunction)Cm_OpenDefaultComponent, 1,
+ "(OSType componentType, OSType componentSubType) -> (ComponentInstance _rv)"},
+ {"RegisterComponentResourceFile", (PyCFunction)Cm_RegisterComponentResourceFile, 1,
+ "(short resRefNum, short global) -> (long _rv)"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_Cm(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(Component, CmpObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Component, CmpObj_Convert);
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(ComponentInstance, CmpInstObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(ComponentInstance, CmpInstObj_Convert);
+
+
+ m = Py_InitModule("_Cm", Cm_methods);
+ d = PyModule_GetDict(m);
+ Cm_Error = PyMac_GetOSErrException();
+ if (Cm_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Cm_Error) != 0)
+ return;
+ ComponentInstance_Type.ob_type = &PyType_Type;
+ Py_INCREF(&ComponentInstance_Type);
+ if (PyDict_SetItemString(d, "ComponentInstanceType", (PyObject *)&ComponentInstance_Type) != 0)
+ Py_FatalError("can't initialize ComponentInstanceType");
+ Component_Type.ob_type = &PyType_Type;
+ Py_INCREF(&Component_Type);
+ if (PyDict_SetItemString(d, "ComponentType", (PyObject *)&Component_Type) != 0)
+ Py_FatalError("can't initialize ComponentType");
+}
+
+/* ========================= End module _Cm ========================= */
+
--- /dev/null
+
+/* ========================== Module _Ctl =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Controls.h>
+#include <ControlDefinitions.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+extern PyObject *_CtlObj_New(ControlHandle);
+extern int _CtlObj_Convert(PyObject *, ControlHandle *);
+
+#define CtlObj_New _CtlObj_New
+#define CtlObj_Convert _CtlObj_Convert
+#endif
+
+staticforward PyObject *CtlObj_WhichControl(ControlHandle);
+
+#define as_Control(h) ((ControlHandle)h)
+#define as_Resource(ctl) ((Handle)ctl)
+#if TARGET_API_MAC_CARBON
+#define GetControlRect(ctl, rectp) GetControlBounds(ctl, rectp)
+#else
+#define GetControlRect(ctl, rectp) (*(rectp) = ((*(ctl))->contrlRect))
+#endif
+
+/*
+** Parse/generate ControlFontStyleRec records
+*/
+#if 0 /* Not needed */
+static PyObject *
+ControlFontStyle_New(ControlFontStyleRec *itself)
+{
+
+ return Py_BuildValue("hhhhhhO&O&", itself->flags, itself->font,
+ itself->size, itself->style, itself->mode, itself->just,
+ QdRGB_New, &itself->foreColor, QdRGB_New, &itself->backColor);
+}
+#endif
+
+static int
+ControlFontStyle_Convert(PyObject *v, ControlFontStyleRec *itself)
+{
+ return PyArg_ParseTuple(v, "hhhhhhO&O&", &itself->flags,
+ &itself->font, &itself->size, &itself->style, &itself->mode,
+ &itself->just, QdRGB_Convert, &itself->foreColor,
+ QdRGB_Convert, &itself->backColor);
+}
+
+/*
+** Parse/generate ControlID records
+*/
+static PyObject *
+PyControlID_New(ControlID *itself)
+{
+
+ return Py_BuildValue("O&l", PyMac_BuildOSType, itself->signature, itself->id);
+}
+
+static int
+PyControlID_Convert(PyObject *v, ControlID *itself)
+{
+ return PyArg_ParseTuple(v, "O&l", PyMac_GetOSType, &itself->signature, &itself->id);
+}
+
+
+/* TrackControl and HandleControlClick callback support */
+static PyObject *tracker;
+static ControlActionUPP mytracker_upp;
+static ControlUserPaneDrawUPP mydrawproc_upp;
+static ControlUserPaneIdleUPP myidleproc_upp;
+static ControlUserPaneHitTestUPP myhittestproc_upp;
+static ControlUserPaneTrackingUPP mytrackingproc_upp;
+
+staticforward int settrackfunc(PyObject *); /* forward */
+staticforward void clrtrackfunc(void); /* forward */
+staticforward int setcallback(PyObject *, OSType, PyObject *, UniversalProcPtr *);
+
+static PyObject *Ctl_Error;
+
+/* ---------------------- Object type Control ----------------------- */
+
+PyTypeObject Control_Type;
+
+#define CtlObj_Check(x) ((x)->ob_type == &Control_Type)
+
+typedef struct ControlObject {
+ PyObject_HEAD
+ ControlHandle ob_itself;
+ PyObject *ob_callbackdict;
+} ControlObject;
+
+PyObject *CtlObj_New(ControlHandle itself)
+{
+ ControlObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(ControlObject, &Control_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ SetControlReference(itself, (long)it);
+ it->ob_callbackdict = NULL;
+ return (PyObject *)it;
+}
+CtlObj_Convert(PyObject *v, ControlHandle *p_itself)
+{
+ if (!CtlObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "Control required");
+ return 0;
+ }
+ *p_itself = ((ControlObject *)v)->ob_itself;
+ return 1;
+}
+
+static void CtlObj_dealloc(ControlObject *self)
+{
+ Py_XDECREF(self->ob_callbackdict);
+ if (self->ob_itself)SetControlReference(self->ob_itself, (long)0); /* Make it forget about us */
+ PyMem_DEL(self);
+}
+
+static PyObject *CtlObj_HiliteControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ControlPartCode hiliteState;
+ if (!PyArg_ParseTuple(_args, "h",
+ &hiliteState))
+ return NULL;
+ HiliteControl(_self->ob_itself,
+ hiliteState);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_ShowControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ShowControl(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_HideControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ HideControl(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_IsControlActive(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsControlActive(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_IsControlVisible(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsControlVisible(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_ActivateControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = ActivateControl(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_DeactivateControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = DeactivateControl(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_SetControlVisibility(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Boolean inIsVisible;
+ Boolean inDoDraw;
+ if (!PyArg_ParseTuple(_args, "bb",
+ &inIsVisible,
+ &inDoDraw))
+ return NULL;
+ _err = SetControlVisibility(_self->ob_itself,
+ inIsVisible,
+ inDoDraw);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_Draw1Control(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ Draw1Control(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetBestControlRect(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Rect outRect;
+ SInt16 outBaseLineOffset;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetBestControlRect(_self->ob_itself,
+ &outRect,
+ &outBaseLineOffset);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&h",
+ PyMac_BuildRect, &outRect,
+ outBaseLineOffset);
+ return _res;
+}
+
+static PyObject *CtlObj_SetControlFontStyle(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ControlFontStyleRec inStyle;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ControlFontStyle_Convert, &inStyle))
+ return NULL;
+ _err = SetControlFontStyle(_self->ob_itself,
+ &inStyle);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_DrawControlInCurrentPort(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DrawControlInCurrentPort(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_SetUpControlBackground(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inDepth;
+ Boolean inIsColorDevice;
+ if (!PyArg_ParseTuple(_args, "hb",
+ &inDepth,
+ &inIsColorDevice))
+ return NULL;
+ _err = SetUpControlBackground(_self->ob_itself,
+ inDepth,
+ inIsColorDevice);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_SetUpControlTextColor(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inDepth;
+ Boolean inIsColorDevice;
+ if (!PyArg_ParseTuple(_args, "hb",
+ &inDepth,
+ &inIsColorDevice))
+ return NULL;
+ _err = SetUpControlTextColor(_self->ob_itself,
+ inDepth,
+ inIsColorDevice);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_DragControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point startPoint;
+ Rect limitRect;
+ Rect slopRect;
+ DragConstraint axis;
+ if (!PyArg_ParseTuple(_args, "O&O&O&H",
+ PyMac_GetPoint, &startPoint,
+ PyMac_GetRect, &limitRect,
+ PyMac_GetRect, &slopRect,
+ &axis))
+ return NULL;
+ DragControl(_self->ob_itself,
+ startPoint,
+ &limitRect,
+ &slopRect,
+ axis);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_TestControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ControlPartCode _rv;
+ Point testPoint;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &testPoint))
+ return NULL;
+ _rv = TestControl(_self->ob_itself,
+ testPoint);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_HandleControlContextualMenuClick(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Point inWhere;
+ Boolean menuDisplayed;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &inWhere))
+ return NULL;
+ _err = HandleControlContextualMenuClick(_self->ob_itself,
+ inWhere,
+ &menuDisplayed);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("b",
+ menuDisplayed);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_GetControlClickActivation(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Point inWhere;
+ EventModifiers inModifiers;
+ ClickActivationResult outResult;
+ if (!PyArg_ParseTuple(_args, "O&H",
+ PyMac_GetPoint, &inWhere,
+ &inModifiers))
+ return NULL;
+ _err = GetControlClickActivation(_self->ob_itself,
+ inWhere,
+ inModifiers,
+ &outResult);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outResult);
+ return _res;
+}
+#endif
+
+static PyObject *CtlObj_HandleControlKey(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ SInt16 inKeyCode;
+ SInt16 inCharCode;
+ EventModifiers inModifiers;
+ if (!PyArg_ParseTuple(_args, "hhH",
+ &inKeyCode,
+ &inCharCode,
+ &inModifiers))
+ return NULL;
+ _rv = HandleControlKey(_self->ob_itself,
+ inKeyCode,
+ inCharCode,
+ inModifiers);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_HandleControlSetCursor(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Point localPoint;
+ EventModifiers modifiers;
+ Boolean cursorWasSet;
+ if (!PyArg_ParseTuple(_args, "O&H",
+ PyMac_GetPoint, &localPoint,
+ &modifiers))
+ return NULL;
+ _err = HandleControlSetCursor(_self->ob_itself,
+ localPoint,
+ modifiers,
+ &cursorWasSet);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("b",
+ cursorWasSet);
+ return _res;
+}
+#endif
+
+static PyObject *CtlObj_MoveControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 h;
+ SInt16 v;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &h,
+ &v))
+ return NULL;
+ MoveControl(_self->ob_itself,
+ h,
+ v);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_SizeControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 w;
+ SInt16 h;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &w,
+ &h))
+ return NULL;
+ SizeControl(_self->ob_itself,
+ w,
+ h);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_SetControlTitle(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Str255 title;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, title))
+ return NULL;
+ SetControlTitle(_self->ob_itself,
+ title);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetControlTitle(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Str255 title;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetControlTitle(_self->ob_itself,
+ title);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildStr255, title);
+ return _res;
+}
+
+static PyObject *CtlObj_GetControlValue(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetControlValue(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_SetControlValue(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 newValue;
+ if (!PyArg_ParseTuple(_args, "h",
+ &newValue))
+ return NULL;
+ SetControlValue(_self->ob_itself,
+ newValue);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetControlMinimum(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetControlMinimum(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_SetControlMinimum(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 newMinimum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &newMinimum))
+ return NULL;
+ SetControlMinimum(_self->ob_itself,
+ newMinimum);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetControlMaximum(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetControlMaximum(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_SetControlMaximum(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 newMaximum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &newMaximum))
+ return NULL;
+ SetControlMaximum(_self->ob_itself,
+ newMaximum);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetControlViewSize(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetControlViewSize(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_SetControlViewSize(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 newViewSize;
+ if (!PyArg_ParseTuple(_args, "l",
+ &newViewSize))
+ return NULL;
+ SetControlViewSize(_self->ob_itself,
+ newViewSize);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetControl32BitValue(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetControl32BitValue(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_SetControl32BitValue(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 newValue;
+ if (!PyArg_ParseTuple(_args, "l",
+ &newValue))
+ return NULL;
+ SetControl32BitValue(_self->ob_itself,
+ newValue);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetControl32BitMaximum(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetControl32BitMaximum(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_SetControl32BitMaximum(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 newMaximum;
+ if (!PyArg_ParseTuple(_args, "l",
+ &newMaximum))
+ return NULL;
+ SetControl32BitMaximum(_self->ob_itself,
+ newMaximum);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetControl32BitMinimum(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetControl32BitMinimum(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_SetControl32BitMinimum(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 newMinimum;
+ if (!PyArg_ParseTuple(_args, "l",
+ &newMinimum))
+ return NULL;
+ SetControl32BitMinimum(_self->ob_itself,
+ newMinimum);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_IsValidControlHandle(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsValidControlHandle(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_SetControlID(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ControlID inID;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyControlID_Convert, &inID))
+ return NULL;
+ _err = SetControlID(_self->ob_itself,
+ &inID);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_GetControlID(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ControlID outID;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetControlID(_self->ob_itself,
+ &outID);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyControlID_New, &outID);
+ return _res;
+}
+#endif
+
+static PyObject *CtlObj_RemoveControlProperty(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ OSType propertyCreator;
+ OSType propertyTag;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &propertyCreator,
+ PyMac_GetOSType, &propertyTag))
+ return NULL;
+ _err = RemoveControlProperty(_self->ob_itself,
+ propertyCreator,
+ propertyTag);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_GetControlPropertyAttributes(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ OSType propertyCreator;
+ OSType propertyTag;
+ UInt32 attributes;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &propertyCreator,
+ PyMac_GetOSType, &propertyTag))
+ return NULL;
+ _err = GetControlPropertyAttributes(_self->ob_itself,
+ propertyCreator,
+ propertyTag,
+ &attributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ attributes);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_ChangeControlPropertyAttributes(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ OSType propertyCreator;
+ OSType propertyTag;
+ UInt32 attributesToSet;
+ UInt32 attributesToClear;
+ if (!PyArg_ParseTuple(_args, "O&O&ll",
+ PyMac_GetOSType, &propertyCreator,
+ PyMac_GetOSType, &propertyTag,
+ &attributesToSet,
+ &attributesToClear))
+ return NULL;
+ _err = ChangeControlPropertyAttributes(_self->ob_itself,
+ propertyCreator,
+ propertyTag,
+ attributesToSet,
+ attributesToClear);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *CtlObj_GetControlRegion(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ControlPartCode inPart;
+ RgnHandle outRegion;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &inPart,
+ ResObj_Convert, &outRegion))
+ return NULL;
+ _err = GetControlRegion(_self->ob_itself,
+ inPart,
+ outRegion);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetControlVariant(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ControlVariant _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetControlVariant(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_SetControlReference(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 data;
+ if (!PyArg_ParseTuple(_args, "l",
+ &data))
+ return NULL;
+ SetControlReference(_self->ob_itself,
+ data);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetControlReference(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetControlReference(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_GetAuxiliaryControlRecord(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ AuxCtlHandle acHndl;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetAuxiliaryControlRecord(_self->ob_itself,
+ &acHndl);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ ResObj_New, acHndl);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_SetControlColor(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CCTabHandle newColorTable;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &newColorTable))
+ return NULL;
+ SetControlColor(_self->ob_itself,
+ newColorTable);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *CtlObj_EmbedControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ControlHandle inContainer;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CtlObj_Convert, &inContainer))
+ return NULL;
+ _err = EmbedControl(_self->ob_itself,
+ inContainer);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_AutoEmbedControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ WindowPtr inWindow;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &inWindow))
+ return NULL;
+ _err = AutoEmbedControl(_self->ob_itself,
+ inWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetSuperControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ControlHandle outParent;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetSuperControl(_self->ob_itself,
+ &outParent);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CtlObj_WhichControl, outParent);
+ return _res;
+}
+
+static PyObject *CtlObj_CountSubControls(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ UInt16 outNumChildren;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = CountSubControls(_self->ob_itself,
+ &outNumChildren);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("H",
+ outNumChildren);
+ return _res;
+}
+
+static PyObject *CtlObj_GetIndexedSubControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ UInt16 inIndex;
+ ControlHandle outSubControl;
+ if (!PyArg_ParseTuple(_args, "H",
+ &inIndex))
+ return NULL;
+ _err = GetIndexedSubControl(_self->ob_itself,
+ inIndex,
+ &outSubControl);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CtlObj_WhichControl, outSubControl);
+ return _res;
+}
+
+static PyObject *CtlObj_SetControlSupervisor(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ControlHandle inBoss;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CtlObj_Convert, &inBoss))
+ return NULL;
+ _err = SetControlSupervisor(_self->ob_itself,
+ inBoss);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetControlFeatures(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ UInt32 outFeatures;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetControlFeatures(_self->ob_itself,
+ &outFeatures);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outFeatures);
+ return _res;
+}
+
+static PyObject *CtlObj_GetControlDataSize(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ControlPartCode inPart;
+ ResType inTagName;
+ Size outMaxSize;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &inPart,
+ PyMac_GetOSType, &inTagName))
+ return NULL;
+ _err = GetControlDataSize(_self->ob_itself,
+ inPart,
+ inTagName,
+ &outMaxSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outMaxSize);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_HandleControlDragTracking(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ DragTrackingMessage inMessage;
+ DragReference inDrag;
+ Boolean outLikesDrag;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &inMessage,
+ DragObj_Convert, &inDrag))
+ return NULL;
+ _err = HandleControlDragTracking(_self->ob_itself,
+ inMessage,
+ inDrag,
+ &outLikesDrag);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("b",
+ outLikesDrag);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_HandleControlDragReceive(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ DragReference inDrag;
+ if (!PyArg_ParseTuple(_args, "O&",
+ DragObj_Convert, &inDrag))
+ return NULL;
+ _err = HandleControlDragReceive(_self->ob_itself,
+ inDrag);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_SetControlDragTrackingEnabled(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Boolean tracks;
+ if (!PyArg_ParseTuple(_args, "b",
+ &tracks))
+ return NULL;
+ _err = SetControlDragTrackingEnabled(_self->ob_itself,
+ tracks);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_IsControlDragTrackingEnabled(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Boolean tracks;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = IsControlDragTrackingEnabled(_self->ob_itself,
+ &tracks);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("b",
+ tracks);
+ return _res;
+}
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+
+static PyObject *CtlObj_GetControlBounds(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect bounds;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetControlBounds(_self->ob_itself,
+ &bounds);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &bounds);
+ return _res;
+}
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+
+static PyObject *CtlObj_IsControlHilited(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsControlHilited(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+
+static PyObject *CtlObj_GetControlHilite(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt16 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetControlHilite(_self->ob_itself);
+ _res = Py_BuildValue("H",
+ _rv);
+ return _res;
+}
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+
+static PyObject *CtlObj_GetControlOwner(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetControlOwner(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+
+static PyObject *CtlObj_GetControlDataHandle(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetControlDataHandle(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+
+static PyObject *CtlObj_GetControlPopupMenuHandle(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetControlPopupMenuHandle(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, _rv);
+ return _res;
+}
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+
+static PyObject *CtlObj_GetControlPopupMenuID(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetControlPopupMenuID(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+
+static PyObject *CtlObj_SetControlDataHandle(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle dataHandle;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &dataHandle))
+ return NULL;
+ SetControlDataHandle(_self->ob_itself,
+ dataHandle);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+
+static PyObject *CtlObj_SetControlBounds(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect bounds;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &bounds))
+ return NULL;
+ SetControlBounds(_self->ob_itself,
+ &bounds);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+
+static PyObject *CtlObj_SetControlPopupMenuHandle(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuHandle popupMenu;
+ if (!PyArg_ParseTuple(_args, "O&",
+ MenuObj_Convert, &popupMenu))
+ return NULL;
+ SetControlPopupMenuHandle(_self->ob_itself,
+ popupMenu);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+
+static PyObject *CtlObj_SetControlPopupMenuID(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short menuID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &menuID))
+ return NULL;
+ SetControlPopupMenuID(_self->ob_itself,
+ menuID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *CtlObj_GetBevelButtonMenuValue(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 outValue;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetBevelButtonMenuValue(_self->ob_itself,
+ &outValue);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ outValue);
+ return _res;
+}
+
+static PyObject *CtlObj_SetBevelButtonMenuValue(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inValue;
+ if (!PyArg_ParseTuple(_args, "h",
+ &inValue))
+ return NULL;
+ _err = SetBevelButtonMenuValue(_self->ob_itself,
+ inValue);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetBevelButtonMenuHandle(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ MenuHandle outHandle;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetBevelButtonMenuHandle(_self->ob_itself,
+ &outHandle);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, outHandle);
+ return _res;
+}
+
+static PyObject *CtlObj_SetBevelButtonTransform(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconTransformType transform;
+ if (!PyArg_ParseTuple(_args, "h",
+ &transform))
+ return NULL;
+ _err = SetBevelButtonTransform(_self->ob_itself,
+ transform);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_SetDisclosureTriangleLastValue(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inValue;
+ if (!PyArg_ParseTuple(_args, "h",
+ &inValue))
+ return NULL;
+ _err = SetDisclosureTriangleLastValue(_self->ob_itself,
+ inValue);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetTabContentRect(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Rect outContentRect;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetTabContentRect(_self->ob_itself,
+ &outContentRect);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &outContentRect);
+ return _res;
+}
+
+static PyObject *CtlObj_SetTabEnabled(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inTabToHilite;
+ Boolean inEnabled;
+ if (!PyArg_ParseTuple(_args, "hb",
+ &inTabToHilite,
+ &inEnabled))
+ return NULL;
+ _err = SetTabEnabled(_self->ob_itself,
+ inTabToHilite,
+ inEnabled);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_SetImageWellTransform(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconTransformType inTransform;
+ if (!PyArg_ParseTuple(_args, "h",
+ &inTransform))
+ return NULL;
+ _err = SetImageWellTransform(_self->ob_itself,
+ inTransform);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_as_Resource(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = as_Resource(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_GetControlRect(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect rect;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetControlRect(_self->ob_itself,
+ &rect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &rect);
+ return _res;
+}
+
+static PyObject *CtlObj_DisposeControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ if ( _self->ob_itself ) {
+ SetControlReference(_self->ob_itself, (long)0); /* Make it forget about us */
+ DisposeControl(_self->ob_itself);
+ _self->ob_itself = NULL;
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+
+}
+
+static PyObject *CtlObj_TrackControl(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ ControlPartCode _rv;
+ Point startPoint;
+ ControlActionUPP upp = 0;
+ PyObject *callback = 0;
+
+ if (!PyArg_ParseTuple(_args, "O&|O",
+ PyMac_GetPoint, &startPoint, &callback))
+ return NULL;
+ if (callback && callback != Py_None) {
+ if (PyInt_Check(callback) && PyInt_AS_LONG(callback) == -1)
+ upp = (ControlActionUPP)-1;
+ else {
+ settrackfunc(callback);
+ upp = mytracker_upp;
+ }
+ }
+ _rv = TrackControl(_self->ob_itself,
+ startPoint,
+ upp);
+ clrtrackfunc();
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+
+}
+
+static PyObject *CtlObj_HandleControlClick(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ ControlPartCode _rv;
+ Point startPoint;
+ SInt16 modifiers;
+ ControlActionUPP upp = 0;
+ PyObject *callback = 0;
+
+ if (!PyArg_ParseTuple(_args, "O&h|O",
+ PyMac_GetPoint, &startPoint,
+ &modifiers,
+ &callback))
+ return NULL;
+ if (callback && callback != Py_None) {
+ if (PyInt_Check(callback) && PyInt_AS_LONG(callback) == -1)
+ upp = (ControlActionUPP)-1;
+ else {
+ settrackfunc(callback);
+ upp = mytracker_upp;
+ }
+ }
+ _rv = HandleControlClick(_self->ob_itself,
+ startPoint,
+ modifiers,
+ upp);
+ clrtrackfunc();
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+
+}
+
+static PyObject *CtlObj_SetControlData(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ OSErr _err;
+ ControlPartCode inPart;
+ ResType inTagName;
+ Size bufferSize;
+ Ptr buffer;
+
+ if (!PyArg_ParseTuple(_args, "hO&s#",
+ &inPart,
+ PyMac_GetOSType, &inTagName,
+ &buffer, &bufferSize))
+ return NULL;
+
+ _err = SetControlData(_self->ob_itself,
+ inPart,
+ inTagName,
+ bufferSize,
+ buffer);
+
+ if (_err != noErr)
+ return PyMac_Error(_err);
+ _res = Py_None;
+ return _res;
+
+}
+
+static PyObject *CtlObj_GetControlData(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ OSErr _err;
+ ControlPartCode inPart;
+ ResType inTagName;
+ Size bufferSize;
+ Ptr buffer;
+ Size outSize;
+
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &inPart,
+ PyMac_GetOSType, &inTagName))
+ return NULL;
+
+ /* allocate a buffer for the data */
+ _err = GetControlDataSize(_self->ob_itself,
+ inPart,
+ inTagName,
+ &bufferSize);
+ if (_err != noErr)
+ return PyMac_Error(_err);
+ buffer = PyMem_NEW(char, bufferSize);
+ if (buffer == NULL)
+ return PyErr_NoMemory();
+
+ _err = GetControlData(_self->ob_itself,
+ inPart,
+ inTagName,
+ bufferSize,
+ buffer,
+ &outSize);
+
+ if (_err != noErr) {
+ PyMem_DEL(buffer);
+ return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("s#", buffer, outSize);
+ PyMem_DEL(buffer);
+ return _res;
+
+}
+
+static PyObject *CtlObj_SetControlData_Handle(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ OSErr _err;
+ ControlPartCode inPart;
+ ResType inTagName;
+ Handle buffer;
+
+ if (!PyArg_ParseTuple(_args, "hO&O&",
+ &inPart,
+ PyMac_GetOSType, &inTagName,
+ OptResObj_Convert, &buffer))
+ return NULL;
+
+ _err = SetControlData(_self->ob_itself,
+ inPart,
+ inTagName,
+ sizeof(buffer),
+ (Ptr)&buffer);
+
+ if (_err != noErr)
+ return PyMac_Error(_err);
+ _res = Py_None;
+ return _res;
+
+}
+
+static PyObject *CtlObj_GetControlData_Handle(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ OSErr _err;
+ ControlPartCode inPart;
+ ResType inTagName;
+ Size bufferSize;
+ Handle hdl;
+
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &inPart,
+ PyMac_GetOSType, &inTagName))
+ return NULL;
+
+ /* Check it is handle-sized */
+ _err = GetControlDataSize(_self->ob_itself,
+ inPart,
+ inTagName,
+ &bufferSize);
+ if (_err != noErr)
+ return PyMac_Error(_err);
+ if (bufferSize != sizeof(Handle)) {
+ PyErr_SetString(Ctl_Error, "GetControlDataSize() != sizeof(Handle)");
+ return NULL;
+ }
+
+ _err = GetControlData(_self->ob_itself,
+ inPart,
+ inTagName,
+ sizeof(Handle),
+ (Ptr)&hdl,
+ &bufferSize);
+
+ if (_err != noErr) {
+ return PyMac_Error(_err);
+ }
+ return Py_BuildValue("O&", OptResObj_New, hdl);
+
+}
+
+static PyObject *CtlObj_SetControlData_Callback(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ OSErr _err;
+ ControlPartCode inPart;
+ ResType inTagName;
+ PyObject *callback;
+ UniversalProcPtr c_callback;
+
+ if (!PyArg_ParseTuple(_args, "hO&O",
+ &inPart,
+ PyMac_GetOSType, &inTagName,
+ &callback))
+ return NULL;
+
+ if ( setcallback((PyObject *)_self, inTagName, callback, &c_callback) < 0 )
+ return NULL;
+ _err = SetControlData(_self->ob_itself,
+ inPart,
+ inTagName,
+ sizeof(c_callback),
+ (Ptr)&c_callback);
+
+ if (_err != noErr)
+ return PyMac_Error(_err);
+ _res = Py_None;
+ return _res;
+
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_GetPopupData(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ PopupPrivateDataHandle hdl;
+
+ if ( (*_self->ob_itself)->contrlData == NULL ) {
+ PyErr_SetString(Ctl_Error, "No contrlData handle in control");
+ return 0;
+ }
+ hdl = (PopupPrivateDataHandle)(*_self->ob_itself)->contrlData;
+ HLock((Handle)hdl);
+ _res = Py_BuildValue("O&i", MenuObj_New, (*hdl)->mHandle, (int)(*hdl)->mID);
+ HUnlock((Handle)hdl);
+ return _res;
+
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *CtlObj_SetPopupData(ControlObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ PopupPrivateDataHandle hdl;
+ MenuHandle mHandle;
+ short mID;
+
+ if (!PyArg_ParseTuple(_args, "O&h", MenuObj_Convert, &mHandle, &mID) )
+ return 0;
+ if ( (*_self->ob_itself)->contrlData == NULL ) {
+ PyErr_SetString(Ctl_Error, "No contrlData handle in control");
+ return 0;
+ }
+ hdl = (PopupPrivateDataHandle)(*_self->ob_itself)->contrlData;
+ (*hdl)->mHandle = mHandle;
+ (*hdl)->mID = mID;
+ Py_INCREF(Py_None);
+ return Py_None;
+
+}
+#endif
+
+static PyMethodDef CtlObj_methods[] = {
+ {"HiliteControl", (PyCFunction)CtlObj_HiliteControl, 1,
+ "(ControlPartCode hiliteState) -> None"},
+ {"ShowControl", (PyCFunction)CtlObj_ShowControl, 1,
+ "() -> None"},
+ {"HideControl", (PyCFunction)CtlObj_HideControl, 1,
+ "() -> None"},
+ {"IsControlActive", (PyCFunction)CtlObj_IsControlActive, 1,
+ "() -> (Boolean _rv)"},
+ {"IsControlVisible", (PyCFunction)CtlObj_IsControlVisible, 1,
+ "() -> (Boolean _rv)"},
+ {"ActivateControl", (PyCFunction)CtlObj_ActivateControl, 1,
+ "() -> None"},
+ {"DeactivateControl", (PyCFunction)CtlObj_DeactivateControl, 1,
+ "() -> None"},
+ {"SetControlVisibility", (PyCFunction)CtlObj_SetControlVisibility, 1,
+ "(Boolean inIsVisible, Boolean inDoDraw) -> None"},
+ {"Draw1Control", (PyCFunction)CtlObj_Draw1Control, 1,
+ "() -> None"},
+ {"GetBestControlRect", (PyCFunction)CtlObj_GetBestControlRect, 1,
+ "() -> (Rect outRect, SInt16 outBaseLineOffset)"},
+ {"SetControlFontStyle", (PyCFunction)CtlObj_SetControlFontStyle, 1,
+ "(ControlFontStyleRec inStyle) -> None"},
+ {"DrawControlInCurrentPort", (PyCFunction)CtlObj_DrawControlInCurrentPort, 1,
+ "() -> None"},
+ {"SetUpControlBackground", (PyCFunction)CtlObj_SetUpControlBackground, 1,
+ "(SInt16 inDepth, Boolean inIsColorDevice) -> None"},
+ {"SetUpControlTextColor", (PyCFunction)CtlObj_SetUpControlTextColor, 1,
+ "(SInt16 inDepth, Boolean inIsColorDevice) -> None"},
+ {"DragControl", (PyCFunction)CtlObj_DragControl, 1,
+ "(Point startPoint, Rect limitRect, Rect slopRect, DragConstraint axis) -> None"},
+ {"TestControl", (PyCFunction)CtlObj_TestControl, 1,
+ "(Point testPoint) -> (ControlPartCode _rv)"},
+
+#if TARGET_API_MAC_CARBON
+ {"HandleControlContextualMenuClick", (PyCFunction)CtlObj_HandleControlContextualMenuClick, 1,
+ "(Point inWhere) -> (Boolean menuDisplayed)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetControlClickActivation", (PyCFunction)CtlObj_GetControlClickActivation, 1,
+ "(Point inWhere, EventModifiers inModifiers) -> (ClickActivationResult outResult)"},
+#endif
+ {"HandleControlKey", (PyCFunction)CtlObj_HandleControlKey, 1,
+ "(SInt16 inKeyCode, SInt16 inCharCode, EventModifiers inModifiers) -> (SInt16 _rv)"},
+
+#if TARGET_API_MAC_CARBON
+ {"HandleControlSetCursor", (PyCFunction)CtlObj_HandleControlSetCursor, 1,
+ "(Point localPoint, EventModifiers modifiers) -> (Boolean cursorWasSet)"},
+#endif
+ {"MoveControl", (PyCFunction)CtlObj_MoveControl, 1,
+ "(SInt16 h, SInt16 v) -> None"},
+ {"SizeControl", (PyCFunction)CtlObj_SizeControl, 1,
+ "(SInt16 w, SInt16 h) -> None"},
+ {"SetControlTitle", (PyCFunction)CtlObj_SetControlTitle, 1,
+ "(Str255 title) -> None"},
+ {"GetControlTitle", (PyCFunction)CtlObj_GetControlTitle, 1,
+ "() -> (Str255 title)"},
+ {"GetControlValue", (PyCFunction)CtlObj_GetControlValue, 1,
+ "() -> (SInt16 _rv)"},
+ {"SetControlValue", (PyCFunction)CtlObj_SetControlValue, 1,
+ "(SInt16 newValue) -> None"},
+ {"GetControlMinimum", (PyCFunction)CtlObj_GetControlMinimum, 1,
+ "() -> (SInt16 _rv)"},
+ {"SetControlMinimum", (PyCFunction)CtlObj_SetControlMinimum, 1,
+ "(SInt16 newMinimum) -> None"},
+ {"GetControlMaximum", (PyCFunction)CtlObj_GetControlMaximum, 1,
+ "() -> (SInt16 _rv)"},
+ {"SetControlMaximum", (PyCFunction)CtlObj_SetControlMaximum, 1,
+ "(SInt16 newMaximum) -> None"},
+ {"GetControlViewSize", (PyCFunction)CtlObj_GetControlViewSize, 1,
+ "() -> (SInt32 _rv)"},
+ {"SetControlViewSize", (PyCFunction)CtlObj_SetControlViewSize, 1,
+ "(SInt32 newViewSize) -> None"},
+ {"GetControl32BitValue", (PyCFunction)CtlObj_GetControl32BitValue, 1,
+ "() -> (SInt32 _rv)"},
+ {"SetControl32BitValue", (PyCFunction)CtlObj_SetControl32BitValue, 1,
+ "(SInt32 newValue) -> None"},
+ {"GetControl32BitMaximum", (PyCFunction)CtlObj_GetControl32BitMaximum, 1,
+ "() -> (SInt32 _rv)"},
+ {"SetControl32BitMaximum", (PyCFunction)CtlObj_SetControl32BitMaximum, 1,
+ "(SInt32 newMaximum) -> None"},
+ {"GetControl32BitMinimum", (PyCFunction)CtlObj_GetControl32BitMinimum, 1,
+ "() -> (SInt32 _rv)"},
+ {"SetControl32BitMinimum", (PyCFunction)CtlObj_SetControl32BitMinimum, 1,
+ "(SInt32 newMinimum) -> None"},
+ {"IsValidControlHandle", (PyCFunction)CtlObj_IsValidControlHandle, 1,
+ "() -> (Boolean _rv)"},
+
+#if TARGET_API_MAC_CARBON
+ {"SetControlID", (PyCFunction)CtlObj_SetControlID, 1,
+ "(ControlID inID) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetControlID", (PyCFunction)CtlObj_GetControlID, 1,
+ "() -> (ControlID outID)"},
+#endif
+ {"RemoveControlProperty", (PyCFunction)CtlObj_RemoveControlProperty, 1,
+ "(OSType propertyCreator, OSType propertyTag) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"GetControlPropertyAttributes", (PyCFunction)CtlObj_GetControlPropertyAttributes, 1,
+ "(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"ChangeControlPropertyAttributes", (PyCFunction)CtlObj_ChangeControlPropertyAttributes, 1,
+ "(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"},
+#endif
+ {"GetControlRegion", (PyCFunction)CtlObj_GetControlRegion, 1,
+ "(ControlPartCode inPart, RgnHandle outRegion) -> None"},
+ {"GetControlVariant", (PyCFunction)CtlObj_GetControlVariant, 1,
+ "() -> (ControlVariant _rv)"},
+ {"SetControlReference", (PyCFunction)CtlObj_SetControlReference, 1,
+ "(SInt32 data) -> None"},
+ {"GetControlReference", (PyCFunction)CtlObj_GetControlReference, 1,
+ "() -> (SInt32 _rv)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"GetAuxiliaryControlRecord", (PyCFunction)CtlObj_GetAuxiliaryControlRecord, 1,
+ "() -> (Boolean _rv, AuxCtlHandle acHndl)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"SetControlColor", (PyCFunction)CtlObj_SetControlColor, 1,
+ "(CCTabHandle newColorTable) -> None"},
+#endif
+ {"EmbedControl", (PyCFunction)CtlObj_EmbedControl, 1,
+ "(ControlHandle inContainer) -> None"},
+ {"AutoEmbedControl", (PyCFunction)CtlObj_AutoEmbedControl, 1,
+ "(WindowPtr inWindow) -> None"},
+ {"GetSuperControl", (PyCFunction)CtlObj_GetSuperControl, 1,
+ "() -> (ControlHandle outParent)"},
+ {"CountSubControls", (PyCFunction)CtlObj_CountSubControls, 1,
+ "() -> (UInt16 outNumChildren)"},
+ {"GetIndexedSubControl", (PyCFunction)CtlObj_GetIndexedSubControl, 1,
+ "(UInt16 inIndex) -> (ControlHandle outSubControl)"},
+ {"SetControlSupervisor", (PyCFunction)CtlObj_SetControlSupervisor, 1,
+ "(ControlHandle inBoss) -> None"},
+ {"GetControlFeatures", (PyCFunction)CtlObj_GetControlFeatures, 1,
+ "() -> (UInt32 outFeatures)"},
+ {"GetControlDataSize", (PyCFunction)CtlObj_GetControlDataSize, 1,
+ "(ControlPartCode inPart, ResType inTagName) -> (Size outMaxSize)"},
+
+#if TARGET_API_MAC_CARBON
+ {"HandleControlDragTracking", (PyCFunction)CtlObj_HandleControlDragTracking, 1,
+ "(DragTrackingMessage inMessage, DragReference inDrag) -> (Boolean outLikesDrag)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"HandleControlDragReceive", (PyCFunction)CtlObj_HandleControlDragReceive, 1,
+ "(DragReference inDrag) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"SetControlDragTrackingEnabled", (PyCFunction)CtlObj_SetControlDragTrackingEnabled, 1,
+ "(Boolean tracks) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"IsControlDragTrackingEnabled", (PyCFunction)CtlObj_IsControlDragTrackingEnabled, 1,
+ "() -> (Boolean tracks)"},
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+ {"GetControlBounds", (PyCFunction)CtlObj_GetControlBounds, 1,
+ "() -> (Rect bounds)"},
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+ {"IsControlHilited", (PyCFunction)CtlObj_IsControlHilited, 1,
+ "() -> (Boolean _rv)"},
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+ {"GetControlHilite", (PyCFunction)CtlObj_GetControlHilite, 1,
+ "() -> (UInt16 _rv)"},
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+ {"GetControlOwner", (PyCFunction)CtlObj_GetControlOwner, 1,
+ "() -> (WindowPtr _rv)"},
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+ {"GetControlDataHandle", (PyCFunction)CtlObj_GetControlDataHandle, 1,
+ "() -> (Handle _rv)"},
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+ {"GetControlPopupMenuHandle", (PyCFunction)CtlObj_GetControlPopupMenuHandle, 1,
+ "() -> (MenuHandle _rv)"},
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+ {"GetControlPopupMenuID", (PyCFunction)CtlObj_GetControlPopupMenuID, 1,
+ "() -> (short _rv)"},
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+ {"SetControlDataHandle", (PyCFunction)CtlObj_SetControlDataHandle, 1,
+ "(Handle dataHandle) -> None"},
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+ {"SetControlBounds", (PyCFunction)CtlObj_SetControlBounds, 1,
+ "(Rect bounds) -> None"},
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+ {"SetControlPopupMenuHandle", (PyCFunction)CtlObj_SetControlPopupMenuHandle, 1,
+ "(MenuHandle popupMenu) -> None"},
+#endif
+
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+ {"SetControlPopupMenuID", (PyCFunction)CtlObj_SetControlPopupMenuID, 1,
+ "(short menuID) -> None"},
+#endif
+ {"GetBevelButtonMenuValue", (PyCFunction)CtlObj_GetBevelButtonMenuValue, 1,
+ "() -> (SInt16 outValue)"},
+ {"SetBevelButtonMenuValue", (PyCFunction)CtlObj_SetBevelButtonMenuValue, 1,
+ "(SInt16 inValue) -> None"},
+ {"GetBevelButtonMenuHandle", (PyCFunction)CtlObj_GetBevelButtonMenuHandle, 1,
+ "() -> (MenuHandle outHandle)"},
+ {"SetBevelButtonTransform", (PyCFunction)CtlObj_SetBevelButtonTransform, 1,
+ "(IconTransformType transform) -> None"},
+ {"SetDisclosureTriangleLastValue", (PyCFunction)CtlObj_SetDisclosureTriangleLastValue, 1,
+ "(SInt16 inValue) -> None"},
+ {"GetTabContentRect", (PyCFunction)CtlObj_GetTabContentRect, 1,
+ "() -> (Rect outContentRect)"},
+ {"SetTabEnabled", (PyCFunction)CtlObj_SetTabEnabled, 1,
+ "(SInt16 inTabToHilite, Boolean inEnabled) -> None"},
+ {"SetImageWellTransform", (PyCFunction)CtlObj_SetImageWellTransform, 1,
+ "(IconTransformType inTransform) -> None"},
+ {"as_Resource", (PyCFunction)CtlObj_as_Resource, 1,
+ "() -> (Handle _rv)"},
+ {"GetControlRect", (PyCFunction)CtlObj_GetControlRect, 1,
+ "() -> (Rect rect)"},
+ {"DisposeControl", (PyCFunction)CtlObj_DisposeControl, 1,
+ "() -> None"},
+ {"TrackControl", (PyCFunction)CtlObj_TrackControl, 1,
+ "(Point startPoint [,trackercallback]) -> (ControlPartCode _rv)"},
+ {"HandleControlClick", (PyCFunction)CtlObj_HandleControlClick, 1,
+ "(Point startPoint, Integer modifiers, [,trackercallback]) -> (ControlPartCode _rv)"},
+ {"SetControlData", (PyCFunction)CtlObj_SetControlData, 1,
+ "(stuff) -> None"},
+ {"GetControlData", (PyCFunction)CtlObj_GetControlData, 1,
+ "(part, type) -> String"},
+ {"SetControlData_Handle", (PyCFunction)CtlObj_SetControlData_Handle, 1,
+ "(ResObj) -> None"},
+ {"GetControlData_Handle", (PyCFunction)CtlObj_GetControlData_Handle, 1,
+ "(part, type) -> ResObj"},
+ {"SetControlData_Callback", (PyCFunction)CtlObj_SetControlData_Callback, 1,
+ "(callbackfunc) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+ {"GetPopupData", (PyCFunction)CtlObj_GetPopupData, 1,
+ NULL},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"SetPopupData", (PyCFunction)CtlObj_SetPopupData, 1,
+ NULL},
+#endif
+ {NULL, NULL, 0}
+};
+
+PyMethodChain CtlObj_chain = { CtlObj_methods, NULL };
+
+static PyObject *CtlObj_getattr(ControlObject *self, char *name)
+{
+ return Py_FindMethodInChain(&CtlObj_chain, (PyObject *)self, name);
+}
+
+#define CtlObj_setattr NULL
+
+static int CtlObj_compare(ControlObject *self, ControlObject *other)
+{
+ unsigned long v, w;
+
+ if (!CtlObj_Check((PyObject *)other))
+ {
+ v=(unsigned long)self;
+ w=(unsigned long)other;
+ }
+ else
+ {
+ v=(unsigned long)self->ob_itself;
+ w=(unsigned long)other->ob_itself;
+ }
+ if( v < w ) return -1;
+ if( v > w ) return 1;
+ return 0;
+}
+
+#define CtlObj_repr NULL
+
+static long CtlObj_hash(ControlObject *self)
+{
+ return (long)self->ob_itself;
+}
+
+PyTypeObject Control_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "Control", /*tp_name*/
+ sizeof(ControlObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) CtlObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) CtlObj_getattr, /*tp_getattr*/
+ (setattrfunc) CtlObj_setattr, /*tp_setattr*/
+ (cmpfunc) CtlObj_compare, /*tp_compare*/
+ (reprfunc) CtlObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) CtlObj_hash, /*tp_hash*/
+};
+
+/* -------------------- End object type Control --------------------- */
+
+
+static PyObject *Ctl_NewControl(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ControlHandle _rv;
+ WindowPtr owningWindow;
+ Rect boundsRect;
+ Str255 controlTitle;
+ Boolean initiallyVisible;
+ SInt16 initialValue;
+ SInt16 minimumValue;
+ SInt16 maximumValue;
+ SInt16 procID;
+ SInt32 controlReference;
+ if (!PyArg_ParseTuple(_args, "O&O&O&bhhhhl",
+ WinObj_Convert, &owningWindow,
+ PyMac_GetRect, &boundsRect,
+ PyMac_GetStr255, controlTitle,
+ &initiallyVisible,
+ &initialValue,
+ &minimumValue,
+ &maximumValue,
+ &procID,
+ &controlReference))
+ return NULL;
+ _rv = NewControl(owningWindow,
+ &boundsRect,
+ controlTitle,
+ initiallyVisible,
+ initialValue,
+ minimumValue,
+ maximumValue,
+ procID,
+ controlReference);
+ _res = Py_BuildValue("O&",
+ CtlObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Ctl_GetNewControl(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ControlHandle _rv;
+ SInt16 resourceID;
+ WindowPtr owningWindow;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &resourceID,
+ WinObj_Convert, &owningWindow))
+ return NULL;
+ _rv = GetNewControl(resourceID,
+ owningWindow);
+ _res = Py_BuildValue("O&",
+ CtlObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Ctl_DrawControls(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr theWindow;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &theWindow))
+ return NULL;
+ DrawControls(theWindow);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Ctl_UpdateControls(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr theWindow;
+ RgnHandle updateRegion;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ WinObj_Convert, &theWindow,
+ ResObj_Convert, &updateRegion))
+ return NULL;
+ UpdateControls(theWindow,
+ updateRegion);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Ctl_FindControl(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ControlPartCode _rv;
+ Point testPoint;
+ WindowPtr theWindow;
+ ControlHandle theControl;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &testPoint,
+ WinObj_Convert, &theWindow))
+ return NULL;
+ _rv = FindControl(testPoint,
+ theWindow,
+ &theControl);
+ _res = Py_BuildValue("hO&",
+ _rv,
+ CtlObj_WhichControl, theControl);
+ return _res;
+}
+
+static PyObject *Ctl_FindControlUnderMouse(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ControlHandle _rv;
+ Point inWhere;
+ WindowPtr inWindow;
+ SInt16 outPart;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &inWhere,
+ WinObj_Convert, &inWindow))
+ return NULL;
+ _rv = FindControlUnderMouse(inWhere,
+ inWindow,
+ &outPart);
+ _res = Py_BuildValue("O&h",
+ CtlObj_New, _rv,
+ outPart);
+ return _res;
+}
+
+static PyObject *Ctl_IdleControls(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr inWindow;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &inWindow))
+ return NULL;
+ IdleControls(inWindow);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Ctl_GetControlByID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowPtr inWindow;
+ ControlID inID;
+ ControlHandle outControl;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ WinObj_Convert, &inWindow,
+ PyControlID_Convert, &inID))
+ return NULL;
+ _err = GetControlByID(inWindow,
+ &inID,
+ &outControl);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CtlObj_WhichControl, outControl);
+ return _res;
+}
+#endif
+
+static PyObject *Ctl_DumpControlHierarchy(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ WindowPtr inWindow;
+ FSSpec inDumpFile;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ WinObj_Convert, &inWindow,
+ PyMac_GetFSSpec, &inDumpFile))
+ return NULL;
+ _err = DumpControlHierarchy(inWindow,
+ &inDumpFile);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Ctl_CreateRootControl(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ WindowPtr inWindow;
+ ControlHandle outControl;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &inWindow))
+ return NULL;
+ _err = CreateRootControl(inWindow,
+ &outControl);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CtlObj_WhichControl, outControl);
+ return _res;
+}
+
+static PyObject *Ctl_GetRootControl(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ WindowPtr inWindow;
+ ControlHandle outControl;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &inWindow))
+ return NULL;
+ _err = GetRootControl(inWindow,
+ &outControl);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CtlObj_WhichControl, outControl);
+ return _res;
+}
+
+static PyObject *Ctl_GetKeyboardFocus(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ WindowPtr inWindow;
+ ControlHandle outControl;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &inWindow))
+ return NULL;
+ _err = GetKeyboardFocus(inWindow,
+ &outControl);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CtlObj_WhichControl, outControl);
+ return _res;
+}
+
+static PyObject *Ctl_SetKeyboardFocus(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ WindowPtr inWindow;
+ ControlHandle inControl;
+ ControlFocusPart inPart;
+ if (!PyArg_ParseTuple(_args, "O&O&h",
+ WinObj_Convert, &inWindow,
+ CtlObj_Convert, &inControl,
+ &inPart))
+ return NULL;
+ _err = SetKeyboardFocus(inWindow,
+ inControl,
+ inPart);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Ctl_AdvanceKeyboardFocus(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ WindowPtr inWindow;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &inWindow))
+ return NULL;
+ _err = AdvanceKeyboardFocus(inWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Ctl_ReverseKeyboardFocus(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ WindowPtr inWindow;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &inWindow))
+ return NULL;
+ _err = ReverseKeyboardFocus(inWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Ctl_ClearKeyboardFocus(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ WindowPtr inWindow;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &inWindow))
+ return NULL;
+ _err = ClearKeyboardFocus(inWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Ctl_SetAutomaticControlDragTrackingEnabledForWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowPtr theWindow;
+ Boolean tracks;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ WinObj_Convert, &theWindow,
+ &tracks))
+ return NULL;
+ _err = SetAutomaticControlDragTrackingEnabledForWindow(theWindow,
+ tracks);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Ctl_IsAutomaticControlDragTrackingEnabledForWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowPtr theWindow;
+ Boolean tracks;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &theWindow))
+ return NULL;
+ _err = IsAutomaticControlDragTrackingEnabledForWindow(theWindow,
+ &tracks);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("b",
+ tracks);
+ return _res;
+}
+#endif
+
+static PyObject *Ctl_as_Control(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ControlHandle _rv;
+ Handle h;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &h))
+ return NULL;
+ _rv = as_Control(h);
+ _res = Py_BuildValue("O&",
+ CtlObj_New, _rv);
+ return _res;
+}
+
+static PyMethodDef Ctl_methods[] = {
+ {"NewControl", (PyCFunction)Ctl_NewControl, 1,
+ "(WindowPtr owningWindow, Rect boundsRect, Str255 controlTitle, Boolean initiallyVisible, SInt16 initialValue, SInt16 minimumValue, SInt16 maximumValue, SInt16 procID, SInt32 controlReference) -> (ControlHandle _rv)"},
+ {"GetNewControl", (PyCFunction)Ctl_GetNewControl, 1,
+ "(SInt16 resourceID, WindowPtr owningWindow) -> (ControlHandle _rv)"},
+ {"DrawControls", (PyCFunction)Ctl_DrawControls, 1,
+ "(WindowPtr theWindow) -> None"},
+ {"UpdateControls", (PyCFunction)Ctl_UpdateControls, 1,
+ "(WindowPtr theWindow, RgnHandle updateRegion) -> None"},
+ {"FindControl", (PyCFunction)Ctl_FindControl, 1,
+ "(Point testPoint, WindowPtr theWindow) -> (ControlPartCode _rv, ControlHandle theControl)"},
+ {"FindControlUnderMouse", (PyCFunction)Ctl_FindControlUnderMouse, 1,
+ "(Point inWhere, WindowPtr inWindow) -> (ControlHandle _rv, SInt16 outPart)"},
+ {"IdleControls", (PyCFunction)Ctl_IdleControls, 1,
+ "(WindowPtr inWindow) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"GetControlByID", (PyCFunction)Ctl_GetControlByID, 1,
+ "(WindowPtr inWindow, ControlID inID) -> (ControlHandle outControl)"},
+#endif
+ {"DumpControlHierarchy", (PyCFunction)Ctl_DumpControlHierarchy, 1,
+ "(WindowPtr inWindow, FSSpec inDumpFile) -> None"},
+ {"CreateRootControl", (PyCFunction)Ctl_CreateRootControl, 1,
+ "(WindowPtr inWindow) -> (ControlHandle outControl)"},
+ {"GetRootControl", (PyCFunction)Ctl_GetRootControl, 1,
+ "(WindowPtr inWindow) -> (ControlHandle outControl)"},
+ {"GetKeyboardFocus", (PyCFunction)Ctl_GetKeyboardFocus, 1,
+ "(WindowPtr inWindow) -> (ControlHandle outControl)"},
+ {"SetKeyboardFocus", (PyCFunction)Ctl_SetKeyboardFocus, 1,
+ "(WindowPtr inWindow, ControlHandle inControl, ControlFocusPart inPart) -> None"},
+ {"AdvanceKeyboardFocus", (PyCFunction)Ctl_AdvanceKeyboardFocus, 1,
+ "(WindowPtr inWindow) -> None"},
+ {"ReverseKeyboardFocus", (PyCFunction)Ctl_ReverseKeyboardFocus, 1,
+ "(WindowPtr inWindow) -> None"},
+ {"ClearKeyboardFocus", (PyCFunction)Ctl_ClearKeyboardFocus, 1,
+ "(WindowPtr inWindow) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"SetAutomaticControlDragTrackingEnabledForWindow", (PyCFunction)Ctl_SetAutomaticControlDragTrackingEnabledForWindow, 1,
+ "(WindowPtr theWindow, Boolean tracks) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"IsAutomaticControlDragTrackingEnabledForWindow", (PyCFunction)Ctl_IsAutomaticControlDragTrackingEnabledForWindow, 1,
+ "(WindowPtr theWindow) -> (Boolean tracks)"},
+#endif
+ {"as_Control", (PyCFunction)Ctl_as_Control, 1,
+ "(Handle h) -> (ControlHandle _rv)"},
+ {NULL, NULL, 0}
+};
+
+
+
+static PyObject *
+CtlObj_NewUnmanaged(ControlHandle itself)
+{
+ ControlObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(ControlObject, &Control_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_callbackdict = NULL;
+ return (PyObject *)it;
+}
+
+static PyObject *
+CtlObj_WhichControl(ControlHandle c)
+{
+ PyObject *it;
+
+ if (c == NULL)
+ it = Py_None;
+ else {
+ it = (PyObject *) GetControlReference(c);
+ /*
+ ** If the refcon is zero or doesn't point back to the Python object
+ ** the control is not ours. Return a temporary object.
+ */
+ if (it == NULL || ((ControlObject *)it)->ob_itself != c)
+ return CtlObj_NewUnmanaged(c);
+ }
+ Py_INCREF(it);
+ return it;
+}
+
+static int
+settrackfunc(PyObject *obj)
+{
+ if (tracker) {
+ PyErr_SetString(Ctl_Error, "Tracker function in use");
+ return 0;
+ }
+ tracker = obj;
+ Py_INCREF(tracker);
+}
+
+static void
+clrtrackfunc(void)
+{
+ Py_XDECREF(tracker);
+ tracker = 0;
+}
+
+static pascal void
+mytracker(ControlHandle ctl, short part)
+{
+ PyObject *args, *rv=0;
+
+ args = Py_BuildValue("(O&i)", CtlObj_WhichControl, ctl, (int)part);
+ if (args && tracker) {
+ rv = PyEval_CallObject(tracker, args);
+ Py_DECREF(args);
+ }
+ if (rv)
+ Py_DECREF(rv);
+ else
+ PySys_WriteStderr("TrackControl or HandleControlClick: exception in tracker function\n");
+}
+
+static int
+setcallback(PyObject *myself, OSType which, PyObject *callback, UniversalProcPtr *uppp)
+{
+ ControlObject *self = (ControlObject *)myself;
+ char keybuf[9];
+
+ if ( which == kControlUserPaneDrawProcTag )
+ *uppp = (UniversalProcPtr)mydrawproc_upp;
+ else if ( which == kControlUserPaneIdleProcTag )
+ *uppp = (UniversalProcPtr)myidleproc_upp;
+ else if ( which == kControlUserPaneHitTestProcTag )
+ *uppp = (UniversalProcPtr)myhittestproc_upp;
+ else if ( which == kControlUserPaneTrackingProcTag )
+ *uppp = (UniversalProcPtr)mytrackingproc_upp;
+ else
+ return -1;
+ /* Only now do we test for clearing of the callback: */
+ if ( callback == Py_None )
+ *uppp = NULL;
+ /* Create the dict if it doesn't exist yet (so we don't get such a dict for every control) */
+ if ( self->ob_callbackdict == NULL )
+ if ( (self->ob_callbackdict = PyDict_New()) == NULL )
+ return -1;
+ /* And store the Python callback */
+ sprintf(keybuf, "%x", which);
+ if (PyDict_SetItemString(self->ob_callbackdict, keybuf, callback) < 0)
+ return -1;
+ return 0;
+}
+
+static PyObject *
+callcallback(ControlObject *self, OSType which, PyObject *arglist)
+{
+ char keybuf[9];
+ PyObject *func, *rv;
+
+ sprintf(keybuf, "%x", which);
+ if ( self->ob_callbackdict == NULL ||
+ (func = PyDict_GetItemString(self->ob_callbackdict, keybuf)) == NULL ) {
+ PySys_WriteStderr("Control callback %x without callback object\n", which);
+ return NULL;
+ }
+ rv = PyEval_CallObject(func, arglist);
+ if ( rv == NULL )
+ PySys_WriteStderr("Exception in control callback %x handler\n", which);
+ return rv;
+}
+
+static pascal void
+mydrawproc(ControlHandle control, SInt16 part)
+{
+ ControlObject *ctl_obj;
+ PyObject *arglist, *rv;
+
+ ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
+ arglist = Py_BuildValue("Oh", ctl_obj, part);
+ rv = callcallback(ctl_obj, kControlUserPaneDrawProcTag, arglist);
+ Py_XDECREF(arglist);
+ Py_XDECREF(rv);
+}
+
+static pascal void
+myidleproc(ControlHandle control)
+{
+ ControlObject *ctl_obj;
+ PyObject *arglist, *rv;
+
+ ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
+ arglist = Py_BuildValue("O", ctl_obj);
+ rv = callcallback(ctl_obj, kControlUserPaneIdleProcTag, arglist);
+ Py_XDECREF(arglist);
+ Py_XDECREF(rv);
+}
+
+static pascal ControlPartCode
+myhittestproc(ControlHandle control, Point where)
+{
+ ControlObject *ctl_obj;
+ PyObject *arglist, *rv;
+ short c_rv = -1;
+
+ ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
+ arglist = Py_BuildValue("OO&", ctl_obj, PyMac_BuildPoint, where);
+ rv = callcallback(ctl_obj, kControlUserPaneHitTestProcTag, arglist);
+ Py_XDECREF(arglist);
+ /* Ignore errors, nothing we can do about them */
+ if ( rv )
+ PyArg_Parse(rv, "h", &c_rv);
+ Py_XDECREF(rv);
+ return (ControlPartCode)c_rv;
+}
+
+static pascal ControlPartCode
+mytrackingproc(ControlHandle control, Point startPt, ControlActionUPP actionProc)
+{
+ ControlObject *ctl_obj;
+ PyObject *arglist, *rv;
+ short c_rv = -1;
+
+ ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
+ /* We cannot pass the actionProc without lots of work */
+ arglist = Py_BuildValue("OO&", ctl_obj, PyMac_BuildPoint, startPt);
+ rv = callcallback(ctl_obj, kControlUserPaneTrackingProcTag, arglist);
+ Py_XDECREF(arglist);
+ if ( rv )
+ PyArg_Parse(rv, "h", &c_rv);
+ Py_XDECREF(rv);
+ return (ControlPartCode)c_rv;
+}
+
+
+void init_Ctl(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ mytracker_upp = NewControlActionUPP(mytracker);
+ mydrawproc_upp = NewControlUserPaneDrawUPP(mydrawproc);
+ myidleproc_upp = NewControlUserPaneIdleUPP(myidleproc);
+ myhittestproc_upp = NewControlUserPaneHitTestUPP(myhittestproc);
+ mytrackingproc_upp = NewControlUserPaneTrackingUPP(mytrackingproc);
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(ControlHandle, CtlObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(ControlHandle, CtlObj_Convert);
+
+
+ m = Py_InitModule("_Ctl", Ctl_methods);
+ d = PyModule_GetDict(m);
+ Ctl_Error = PyMac_GetOSErrException();
+ if (Ctl_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Ctl_Error) != 0)
+ return;
+ Control_Type.ob_type = &PyType_Type;
+ Py_INCREF(&Control_Type);
+ if (PyDict_SetItemString(d, "ControlType", (PyObject *)&Control_Type) != 0)
+ Py_FatalError("can't initialize ControlType");
+}
+
+/* ======================== End module _Ctl ========================= */
+
--- /dev/null
+
+/* ========================== Module _Dlg =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Dialogs.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+extern PyObject *_DlgObj_New(DialogRef);
+extern PyObject *_DlgObj_WhichDialog(DialogRef);
+extern int _DlgObj_Convert(PyObject *, DialogRef *);
+
+#define DlgObj_New _DlgObj_New
+#define DlgObj_WhichDialog _DlgObj_WhichDialog
+#define DlgObj_Convert _DlgObj_Convert
+#endif
+
+#if !ACCESSOR_CALLS_ARE_FUNCTIONS
+#define GetDialogTextEditHandle(dlg) (((DialogPeek)(dlg))->textH)
+#define SetPortDialogPort(dlg) SetPort(dlg)
+#define GetDialogPort(dlg) ((CGrafPtr)(dlg))
+#define GetDialogFromWindow(win) ((DialogRef)(win))
+#endif
+
+/* XXX Shouldn't this be a stack? */
+static PyObject *Dlg_FilterProc_callback = NULL;
+
+static pascal Boolean Dlg_UnivFilterProc(DialogPtr dialog,
+ EventRecord *event,
+ short *itemHit)
+{
+ Boolean rv;
+ PyObject *args, *res;
+ PyObject *callback = Dlg_FilterProc_callback;
+ if (callback == NULL)
+ return 0; /* Default behavior */
+ Dlg_FilterProc_callback = NULL; /* We'll restore it when call successful */
+ args = Py_BuildValue("O&O&", DlgObj_WhichDialog, dialog, PyMac_BuildEventRecord, event);
+ if (args == NULL)
+ res = NULL;
+ else {
+ res = PyEval_CallObject(callback, args);
+ Py_DECREF(args);
+ }
+ if (res == NULL) {
+ PySys_WriteStderr("Exception in Dialog Filter\n");
+ PyErr_Print();
+ *itemHit = -1; /* Fake return item */
+ return 1; /* We handled it */
+ }
+ else {
+ Dlg_FilterProc_callback = callback;
+ if (PyInt_Check(res)) {
+ *itemHit = PyInt_AsLong(res);
+ rv = 1;
+ }
+ else
+ rv = PyObject_IsTrue(res);
+ }
+ Py_DECREF(res);
+ return rv;
+}
+
+static ModalFilterUPP
+Dlg_PassFilterProc(PyObject *callback)
+{
+ PyObject *tmp = Dlg_FilterProc_callback;
+ static ModalFilterUPP UnivFilterUpp = NULL;
+
+ Dlg_FilterProc_callback = NULL;
+ if (callback == Py_None) {
+ Py_XDECREF(tmp);
+ return NULL;
+ }
+ Py_INCREF(callback);
+ Dlg_FilterProc_callback = callback;
+ Py_XDECREF(tmp);
+ if ( UnivFilterUpp == NULL )
+ UnivFilterUpp = NewModalFilterUPP(&Dlg_UnivFilterProc);
+ return UnivFilterUpp;
+}
+
+static PyObject *Dlg_UserItemProc_callback = NULL;
+
+static pascal void Dlg_UnivUserItemProc(DialogPtr dialog,
+ short item)
+{
+ PyObject *args, *res;
+
+ if (Dlg_UserItemProc_callback == NULL)
+ return; /* Default behavior */
+ Dlg_FilterProc_callback = NULL; /* We'll restore it when call successful */
+ args = Py_BuildValue("O&h", DlgObj_WhichDialog, dialog, item);
+ if (args == NULL)
+ res = NULL;
+ else {
+ res = PyEval_CallObject(Dlg_UserItemProc_callback, args);
+ Py_DECREF(args);
+ }
+ if (res == NULL) {
+ PySys_WriteStderr("Exception in Dialog UserItem proc\n");
+ PyErr_Print();
+ }
+ Py_XDECREF(res);
+ return;
+}
+
+#if 0
+/*
+** Treating DialogObjects as WindowObjects is (I think) illegal under Carbon.
+** However, as they are still identical under MacOS9 Carbon this is a problem, even
+** if we neatly call GetDialogWindow() at the right places: there's one refcon field
+** and it points to the DialogObject, so WinObj_WhichWindow will smartly return the
+** dialog object, and therefore we still don't have a WindowObject.
+** I'll leave the chaining code in place for now, with this comment to warn the
+** unsuspecting victims (i.e. me, probably, in a few weeks:-)
+*/
+extern PyMethodChain WinObj_chain;
+#endif
+
+static PyObject *Dlg_Error;
+
+/* ----------------------- Object type Dialog ----------------------- */
+
+PyTypeObject Dialog_Type;
+
+#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
+
+typedef struct DialogObject {
+ PyObject_HEAD
+ DialogPtr ob_itself;
+} DialogObject;
+
+PyObject *DlgObj_New(DialogPtr itself)
+{
+ DialogObject *it;
+ if (itself == NULL) return Py_None;
+ it = PyObject_NEW(DialogObject, &Dialog_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ SetWRefCon(GetDialogWindow(itself), (long)it);
+ return (PyObject *)it;
+}
+DlgObj_Convert(PyObject *v, DialogPtr *p_itself)
+{
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ if (PyInt_Check(v)) { *p_itself = (DialogPtr)PyInt_AsLong(v);
+ return 1; }
+ if (!DlgObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "Dialog required");
+ return 0;
+ }
+ *p_itself = ((DialogObject *)v)->ob_itself;
+ return 1;
+}
+
+static void DlgObj_dealloc(DialogObject *self)
+{
+ DisposeDialog(self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *DlgObj_DrawDialog(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DrawDialog(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_UpdateDialog(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle updateRgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &updateRgn))
+ return NULL;
+ UpdateDialog(_self->ob_itself,
+ updateRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_HideDialogItem(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogItemIndex itemNo;
+ if (!PyArg_ParseTuple(_args, "h",
+ &itemNo))
+ return NULL;
+ HideDialogItem(_self->ob_itself,
+ itemNo);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_ShowDialogItem(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogItemIndex itemNo;
+ if (!PyArg_ParseTuple(_args, "h",
+ &itemNo))
+ return NULL;
+ ShowDialogItem(_self->ob_itself,
+ itemNo);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_FindDialogItem(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogItemIndexZeroBased _rv;
+ Point thePt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &thePt))
+ return NULL;
+ _rv = FindDialogItem(_self->ob_itself,
+ thePt);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *DlgObj_DialogCut(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DialogCut(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_DialogPaste(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DialogPaste(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_DialogCopy(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DialogCopy(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_DialogDelete(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DialogDelete(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_GetDialogItem(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogItemIndex itemNo;
+ DialogItemType itemType;
+ Handle item;
+ Rect box;
+ if (!PyArg_ParseTuple(_args, "h",
+ &itemNo))
+ return NULL;
+ GetDialogItem(_self->ob_itself,
+ itemNo,
+ &itemType,
+ &item,
+ &box);
+ _res = Py_BuildValue("hO&O&",
+ itemType,
+ OptResObj_New, item,
+ PyMac_BuildRect, &box);
+ return _res;
+}
+
+static PyObject *DlgObj_SetDialogItem(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogItemIndex itemNo;
+ DialogItemType itemType;
+ Handle item;
+ Rect box;
+ if (!PyArg_ParseTuple(_args, "hhO&O&",
+ &itemNo,
+ &itemType,
+ ResObj_Convert, &item,
+ PyMac_GetRect, &box))
+ return NULL;
+ SetDialogItem(_self->ob_itself,
+ itemNo,
+ itemType,
+ item,
+ &box);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_SelectDialogItemText(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogItemIndex itemNo;
+ SInt16 strtSel;
+ SInt16 endSel;
+ if (!PyArg_ParseTuple(_args, "hhh",
+ &itemNo,
+ &strtSel,
+ &endSel))
+ return NULL;
+ SelectDialogItemText(_self->ob_itself,
+ itemNo,
+ strtSel,
+ endSel);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_AppendDITL(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle theHandle;
+ DITLMethod method;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ ResObj_Convert, &theHandle,
+ &method))
+ return NULL;
+ AppendDITL(_self->ob_itself,
+ theHandle,
+ method);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_CountDITL(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogItemIndex _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CountDITL(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *DlgObj_ShortenDITL(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogItemIndex numberItems;
+ if (!PyArg_ParseTuple(_args, "h",
+ &numberItems))
+ return NULL;
+ ShortenDITL(_self->ob_itself,
+ numberItems);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *DlgObj_InsertDialogItem(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ DialogItemIndex afterItem;
+ DialogItemType itemType;
+ Handle itemHandle;
+ Rect box;
+ if (!PyArg_ParseTuple(_args, "hhO&O&",
+ &afterItem,
+ &itemType,
+ ResObj_Convert, &itemHandle,
+ PyMac_GetRect, &box))
+ return NULL;
+ _err = InsertDialogItem(_self->ob_itself,
+ afterItem,
+ itemType,
+ itemHandle,
+ &box);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *DlgObj_RemoveDialogItems(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ DialogItemIndex itemNo;
+ DialogItemIndex amountToRemove;
+ Boolean disposeItemData;
+ if (!PyArg_ParseTuple(_args, "hhb",
+ &itemNo,
+ &amountToRemove,
+ &disposeItemData))
+ return NULL;
+ _err = RemoveDialogItems(_self->ob_itself,
+ itemNo,
+ amountToRemove,
+ disposeItemData);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *DlgObj_StdFilterProc(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventRecord event;
+ DialogItemIndex itemHit;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = StdFilterProc(_self->ob_itself,
+ &event,
+ &itemHit);
+ _res = Py_BuildValue("bO&h",
+ _rv,
+ PyMac_BuildEventRecord, &event,
+ itemHit);
+ return _res;
+}
+
+static PyObject *DlgObj_SetDialogDefaultItem(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ DialogItemIndex newItem;
+ if (!PyArg_ParseTuple(_args, "h",
+ &newItem))
+ return NULL;
+ _err = SetDialogDefaultItem(_self->ob_itself,
+ newItem);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_SetDialogCancelItem(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ DialogItemIndex newItem;
+ if (!PyArg_ParseTuple(_args, "h",
+ &newItem))
+ return NULL;
+ _err = SetDialogCancelItem(_self->ob_itself,
+ newItem);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_SetDialogTracksCursor(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Boolean tracks;
+ if (!PyArg_ParseTuple(_args, "b",
+ &tracks))
+ return NULL;
+ _err = SetDialogTracksCursor(_self->ob_itself,
+ tracks);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_AutoSizeDialog(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = AutoSizeDialog(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_GetDialogItemAsControl(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItemNo;
+ ControlHandle outControl;
+ if (!PyArg_ParseTuple(_args, "h",
+ &inItemNo))
+ return NULL;
+ _err = GetDialogItemAsControl(_self->ob_itself,
+ inItemNo,
+ &outControl);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CtlObj_New, outControl);
+ return _res;
+}
+
+static PyObject *DlgObj_MoveDialogItem(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItemNo;
+ SInt16 inHoriz;
+ SInt16 inVert;
+ if (!PyArg_ParseTuple(_args, "hhh",
+ &inItemNo,
+ &inHoriz,
+ &inVert))
+ return NULL;
+ _err = MoveDialogItem(_self->ob_itself,
+ inItemNo,
+ inHoriz,
+ inVert);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_SizeDialogItem(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItemNo;
+ SInt16 inWidth;
+ SInt16 inHeight;
+ if (!PyArg_ParseTuple(_args, "hhh",
+ &inItemNo,
+ &inWidth,
+ &inHeight))
+ return NULL;
+ _err = SizeDialogItem(_self->ob_itself,
+ inItemNo,
+ inWidth,
+ inHeight);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_AppendDialogItemList(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 ditlID;
+ DITLMethod method;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &ditlID,
+ &method))
+ return NULL;
+ _err = AppendDialogItemList(_self->ob_itself,
+ ditlID,
+ method);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_SetDialogTimeout(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ SInt16 inButtonToPress;
+ UInt32 inSecondsToWait;
+ if (!PyArg_ParseTuple(_args, "hl",
+ &inButtonToPress,
+ &inSecondsToWait))
+ return NULL;
+ _err = SetDialogTimeout(_self->ob_itself,
+ inButtonToPress,
+ inSecondsToWait);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_GetDialogTimeout(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ SInt16 outButtonToPress;
+ UInt32 outSecondsToWait;
+ UInt32 outSecondsRemaining;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetDialogTimeout(_self->ob_itself,
+ &outButtonToPress,
+ &outSecondsToWait,
+ &outSecondsRemaining);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("hll",
+ outButtonToPress,
+ outSecondsToWait,
+ outSecondsRemaining);
+ return _res;
+}
+
+static PyObject *DlgObj_SetModalDialogEventMask(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ EventMask inMask;
+ if (!PyArg_ParseTuple(_args, "H",
+ &inMask))
+ return NULL;
+ _err = SetModalDialogEventMask(_self->ob_itself,
+ inMask);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_GetModalDialogEventMask(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ EventMask outMask;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetModalDialogEventMask(_self->ob_itself,
+ &outMask);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("H",
+ outMask);
+ return _res;
+}
+
+static PyObject *DlgObj_GetDialogWindow(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetDialogWindow(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+
+static PyObject *DlgObj_GetDialogTextEditHandle(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TEHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetDialogTextEditHandle(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *DlgObj_GetDialogDefaultItem(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetDialogDefaultItem(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *DlgObj_GetDialogCancelItem(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetDialogCancelItem(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *DlgObj_GetDialogKeyboardFocusItem(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetDialogKeyboardFocusItem(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *DlgObj_SetPortDialogPort(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ SetPortDialogPort(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_GetDialogPort(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetDialogPort(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ GrafObj_New, _rv);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *DlgObj_SetGrafPortOfDialog(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ SetGrafPortOfDialog(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyMethodDef DlgObj_methods[] = {
+ {"DrawDialog", (PyCFunction)DlgObj_DrawDialog, 1,
+ "() -> None"},
+ {"UpdateDialog", (PyCFunction)DlgObj_UpdateDialog, 1,
+ "(RgnHandle updateRgn) -> None"},
+ {"HideDialogItem", (PyCFunction)DlgObj_HideDialogItem, 1,
+ "(DialogItemIndex itemNo) -> None"},
+ {"ShowDialogItem", (PyCFunction)DlgObj_ShowDialogItem, 1,
+ "(DialogItemIndex itemNo) -> None"},
+ {"FindDialogItem", (PyCFunction)DlgObj_FindDialogItem, 1,
+ "(Point thePt) -> (DialogItemIndexZeroBased _rv)"},
+ {"DialogCut", (PyCFunction)DlgObj_DialogCut, 1,
+ "() -> None"},
+ {"DialogPaste", (PyCFunction)DlgObj_DialogPaste, 1,
+ "() -> None"},
+ {"DialogCopy", (PyCFunction)DlgObj_DialogCopy, 1,
+ "() -> None"},
+ {"DialogDelete", (PyCFunction)DlgObj_DialogDelete, 1,
+ "() -> None"},
+ {"GetDialogItem", (PyCFunction)DlgObj_GetDialogItem, 1,
+ "(DialogItemIndex itemNo) -> (DialogItemType itemType, Handle item, Rect box)"},
+ {"SetDialogItem", (PyCFunction)DlgObj_SetDialogItem, 1,
+ "(DialogItemIndex itemNo, DialogItemType itemType, Handle item, Rect box) -> None"},
+ {"SelectDialogItemText", (PyCFunction)DlgObj_SelectDialogItemText, 1,
+ "(DialogItemIndex itemNo, SInt16 strtSel, SInt16 endSel) -> None"},
+ {"AppendDITL", (PyCFunction)DlgObj_AppendDITL, 1,
+ "(Handle theHandle, DITLMethod method) -> None"},
+ {"CountDITL", (PyCFunction)DlgObj_CountDITL, 1,
+ "() -> (DialogItemIndex _rv)"},
+ {"ShortenDITL", (PyCFunction)DlgObj_ShortenDITL, 1,
+ "(DialogItemIndex numberItems) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"InsertDialogItem", (PyCFunction)DlgObj_InsertDialogItem, 1,
+ "(DialogItemIndex afterItem, DialogItemType itemType, Handle itemHandle, Rect box) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"RemoveDialogItems", (PyCFunction)DlgObj_RemoveDialogItems, 1,
+ "(DialogItemIndex itemNo, DialogItemIndex amountToRemove, Boolean disposeItemData) -> None"},
+#endif
+ {"StdFilterProc", (PyCFunction)DlgObj_StdFilterProc, 1,
+ "() -> (Boolean _rv, EventRecord event, DialogItemIndex itemHit)"},
+ {"SetDialogDefaultItem", (PyCFunction)DlgObj_SetDialogDefaultItem, 1,
+ "(DialogItemIndex newItem) -> None"},
+ {"SetDialogCancelItem", (PyCFunction)DlgObj_SetDialogCancelItem, 1,
+ "(DialogItemIndex newItem) -> None"},
+ {"SetDialogTracksCursor", (PyCFunction)DlgObj_SetDialogTracksCursor, 1,
+ "(Boolean tracks) -> None"},
+ {"AutoSizeDialog", (PyCFunction)DlgObj_AutoSizeDialog, 1,
+ "() -> None"},
+ {"GetDialogItemAsControl", (PyCFunction)DlgObj_GetDialogItemAsControl, 1,
+ "(SInt16 inItemNo) -> (ControlHandle outControl)"},
+ {"MoveDialogItem", (PyCFunction)DlgObj_MoveDialogItem, 1,
+ "(SInt16 inItemNo, SInt16 inHoriz, SInt16 inVert) -> None"},
+ {"SizeDialogItem", (PyCFunction)DlgObj_SizeDialogItem, 1,
+ "(SInt16 inItemNo, SInt16 inWidth, SInt16 inHeight) -> None"},
+ {"AppendDialogItemList", (PyCFunction)DlgObj_AppendDialogItemList, 1,
+ "(SInt16 ditlID, DITLMethod method) -> None"},
+ {"SetDialogTimeout", (PyCFunction)DlgObj_SetDialogTimeout, 1,
+ "(SInt16 inButtonToPress, UInt32 inSecondsToWait) -> None"},
+ {"GetDialogTimeout", (PyCFunction)DlgObj_GetDialogTimeout, 1,
+ "() -> (SInt16 outButtonToPress, UInt32 outSecondsToWait, UInt32 outSecondsRemaining)"},
+ {"SetModalDialogEventMask", (PyCFunction)DlgObj_SetModalDialogEventMask, 1,
+ "(EventMask inMask) -> None"},
+ {"GetModalDialogEventMask", (PyCFunction)DlgObj_GetModalDialogEventMask, 1,
+ "() -> (EventMask outMask)"},
+ {"GetDialogWindow", (PyCFunction)DlgObj_GetDialogWindow, 1,
+ "() -> (WindowPtr _rv)"},
+ {"GetDialogTextEditHandle", (PyCFunction)DlgObj_GetDialogTextEditHandle, 1,
+ "() -> (TEHandle _rv)"},
+ {"GetDialogDefaultItem", (PyCFunction)DlgObj_GetDialogDefaultItem, 1,
+ "() -> (SInt16 _rv)"},
+ {"GetDialogCancelItem", (PyCFunction)DlgObj_GetDialogCancelItem, 1,
+ "() -> (SInt16 _rv)"},
+ {"GetDialogKeyboardFocusItem", (PyCFunction)DlgObj_GetDialogKeyboardFocusItem, 1,
+ "() -> (SInt16 _rv)"},
+ {"SetPortDialogPort", (PyCFunction)DlgObj_SetPortDialogPort, 1,
+ "() -> None"},
+ {"GetDialogPort", (PyCFunction)DlgObj_GetDialogPort, 1,
+ "() -> (CGrafPtr _rv)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"SetGrafPortOfDialog", (PyCFunction)DlgObj_SetGrafPortOfDialog, 1,
+ "() -> None"},
+#endif
+ {NULL, NULL, 0}
+};
+
+PyMethodChain DlgObj_chain = { DlgObj_methods, NULL };
+
+static PyObject *DlgObj_getattr(DialogObject *self, char *name)
+{
+ return Py_FindMethodInChain(&DlgObj_chain, (PyObject *)self, name);
+}
+
+#define DlgObj_setattr NULL
+
+static int DlgObj_compare(DialogObject *self, DialogObject *other)
+{
+ if ( self->ob_itself > other->ob_itself ) return 1;
+ if ( self->ob_itself < other->ob_itself ) return -1;
+ return 0;
+}
+
+#define DlgObj_repr NULL
+
+static int DlgObj_hash(DialogObject *self)
+{
+ return (int)self->ob_itself;
+}
+
+PyTypeObject Dialog_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "Dialog", /*tp_name*/
+ sizeof(DialogObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) DlgObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) DlgObj_getattr, /*tp_getattr*/
+ (setattrfunc) DlgObj_setattr, /*tp_setattr*/
+ (cmpfunc) DlgObj_compare, /*tp_compare*/
+ (reprfunc) DlgObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) DlgObj_hash, /*tp_hash*/
+};
+
+/* --------------------- End object type Dialog --------------------- */
+
+
+static PyObject *Dlg_NewDialog(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogPtr _rv;
+ Rect boundsRect;
+ Str255 title;
+ Boolean visible;
+ SInt16 procID;
+ WindowPtr behind;
+ Boolean goAwayFlag;
+ SInt32 refCon;
+ Handle items;
+ if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&",
+ PyMac_GetRect, &boundsRect,
+ PyMac_GetStr255, title,
+ &visible,
+ &procID,
+ WinObj_Convert, &behind,
+ &goAwayFlag,
+ &refCon,
+ ResObj_Convert, &items))
+ return NULL;
+ _rv = NewDialog((void *)0,
+ &boundsRect,
+ title,
+ visible,
+ procID,
+ behind,
+ goAwayFlag,
+ refCon,
+ items);
+ _res = Py_BuildValue("O&",
+ DlgObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Dlg_GetNewDialog(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogPtr _rv;
+ SInt16 dialogID;
+ WindowPtr behind;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &dialogID,
+ WinObj_Convert, &behind))
+ return NULL;
+ _rv = GetNewDialog(dialogID,
+ (void *)0,
+ behind);
+ _res = Py_BuildValue("O&",
+ DlgObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Dlg_NewColorDialog(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogPtr _rv;
+ Rect boundsRect;
+ Str255 title;
+ Boolean visible;
+ SInt16 procID;
+ WindowPtr behind;
+ Boolean goAwayFlag;
+ SInt32 refCon;
+ Handle items;
+ if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&",
+ PyMac_GetRect, &boundsRect,
+ PyMac_GetStr255, title,
+ &visible,
+ &procID,
+ WinObj_Convert, &behind,
+ &goAwayFlag,
+ &refCon,
+ ResObj_Convert, &items))
+ return NULL;
+ _rv = NewColorDialog((void *)0,
+ &boundsRect,
+ title,
+ visible,
+ procID,
+ behind,
+ goAwayFlag,
+ refCon,
+ items);
+ _res = Py_BuildValue("O&",
+ DlgObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Dlg_ModalDialog(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyObject* modalFilter;
+ DialogItemIndex itemHit;
+ if (!PyArg_ParseTuple(_args, "O",
+ &modalFilter))
+ return NULL;
+ ModalDialog(Dlg_PassFilterProc(modalFilter),
+ &itemHit);
+ _res = Py_BuildValue("h",
+ itemHit);
+ return _res;
+}
+
+static PyObject *Dlg_IsDialogEvent(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventRecord theEvent;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &theEvent))
+ return NULL;
+ _rv = IsDialogEvent(&theEvent);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Dlg_DialogSelect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventRecord theEvent;
+ DialogPtr theDialog;
+ DialogItemIndex itemHit;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &theEvent))
+ return NULL;
+ _rv = DialogSelect(&theEvent,
+ &theDialog,
+ &itemHit);
+ _res = Py_BuildValue("bO&h",
+ _rv,
+ DlgObj_WhichDialog, theDialog,
+ itemHit);
+ return _res;
+}
+
+static PyObject *Dlg_Alert(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogItemIndex _rv;
+ SInt16 alertID;
+ PyObject* modalFilter;
+ if (!PyArg_ParseTuple(_args, "hO",
+ &alertID,
+ &modalFilter))
+ return NULL;
+ _rv = Alert(alertID,
+ Dlg_PassFilterProc(modalFilter));
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Dlg_StopAlert(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogItemIndex _rv;
+ SInt16 alertID;
+ PyObject* modalFilter;
+ if (!PyArg_ParseTuple(_args, "hO",
+ &alertID,
+ &modalFilter))
+ return NULL;
+ _rv = StopAlert(alertID,
+ Dlg_PassFilterProc(modalFilter));
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Dlg_NoteAlert(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogItemIndex _rv;
+ SInt16 alertID;
+ PyObject* modalFilter;
+ if (!PyArg_ParseTuple(_args, "hO",
+ &alertID,
+ &modalFilter))
+ return NULL;
+ _rv = NoteAlert(alertID,
+ Dlg_PassFilterProc(modalFilter));
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Dlg_CautionAlert(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogItemIndex _rv;
+ SInt16 alertID;
+ PyObject* modalFilter;
+ if (!PyArg_ParseTuple(_args, "hO",
+ &alertID,
+ &modalFilter))
+ return NULL;
+ _rv = CautionAlert(alertID,
+ Dlg_PassFilterProc(modalFilter));
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Dlg_ParamText(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Str255 param0;
+ Str255 param1;
+ Str255 param2;
+ Str255 param3;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+ PyMac_GetStr255, param0,
+ PyMac_GetStr255, param1,
+ PyMac_GetStr255, param2,
+ PyMac_GetStr255, param3))
+ return NULL;
+ ParamText(param0,
+ param1,
+ param2,
+ param3);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Dlg_GetDialogItemText(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle item;
+ Str255 text;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &item))
+ return NULL;
+ GetDialogItemText(item,
+ text);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildStr255, text);
+ return _res;
+}
+
+static PyObject *Dlg_SetDialogItemText(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle item;
+ Str255 text;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &item,
+ PyMac_GetStr255, text))
+ return NULL;
+ SetDialogItemText(item,
+ text);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Dlg_GetAlertStage(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetAlertStage();
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Dlg_SetDialogFont(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 fontNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &fontNum))
+ return NULL;
+ SetDialogFont(fontNum);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Dlg_ResetAlertStage(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ResetAlertStage();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Dlg_GetParamText(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Str255 param0;
+ Str255 param1;
+ Str255 param2;
+ Str255 param3;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+ PyMac_GetStr255, param0,
+ PyMac_GetStr255, param1,
+ PyMac_GetStr255, param2,
+ PyMac_GetStr255, param3))
+ return NULL;
+ GetParamText(param0,
+ param1,
+ param2,
+ param3);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Dlg_NewFeaturesDialog(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogPtr _rv;
+ Rect inBoundsRect;
+ Str255 inTitle;
+ Boolean inIsVisible;
+ SInt16 inProcID;
+ WindowPtr inBehind;
+ Boolean inGoAwayFlag;
+ SInt32 inRefCon;
+ Handle inItemListHandle;
+ UInt32 inFlags;
+ if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&l",
+ PyMac_GetRect, &inBoundsRect,
+ PyMac_GetStr255, inTitle,
+ &inIsVisible,
+ &inProcID,
+ WinObj_Convert, &inBehind,
+ &inGoAwayFlag,
+ &inRefCon,
+ ResObj_Convert, &inItemListHandle,
+ &inFlags))
+ return NULL;
+ _rv = NewFeaturesDialog((void *)0,
+ &inBoundsRect,
+ inTitle,
+ inIsVisible,
+ inProcID,
+ inBehind,
+ inGoAwayFlag,
+ inRefCon,
+ inItemListHandle,
+ inFlags);
+ _res = Py_BuildValue("O&",
+ DlgObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Dlg_GetDialogFromWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DialogPtr _rv;
+ WindowPtr window;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &window))
+ return NULL;
+ _rv = GetDialogFromWindow(window);
+ _res = Py_BuildValue("O&",
+ DlgObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Dlg_SetUserItemHandler(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ PyObject *new = NULL;
+
+
+ if (!PyArg_ParseTuple(_args, "|O", &new))
+ return NULL;
+
+ if (Dlg_UserItemProc_callback && new && new != Py_None) {
+ PyErr_SetString(Dlg_Error, "Another UserItemProc is already installed");
+ return NULL;
+ }
+
+ if (new == NULL || new == Py_None) {
+ new = NULL;
+ _res = Py_None;
+ Py_INCREF(Py_None);
+ } else {
+ Py_INCREF(new);
+ _res = Py_BuildValue("O&", ResObj_New, (Handle)NewUserItemUPP(Dlg_UnivUserItemProc));
+ }
+
+ Dlg_UserItemProc_callback = new;
+ return _res;
+
+}
+
+static PyMethodDef Dlg_methods[] = {
+ {"NewDialog", (PyCFunction)Dlg_NewDialog, 1,
+ "(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)"},
+ {"GetNewDialog", (PyCFunction)Dlg_GetNewDialog, 1,
+ "(SInt16 dialogID, WindowPtr behind) -> (DialogPtr _rv)"},
+ {"NewColorDialog", (PyCFunction)Dlg_NewColorDialog, 1,
+ "(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)"},
+ {"ModalDialog", (PyCFunction)Dlg_ModalDialog, 1,
+ "(PyObject* modalFilter) -> (DialogItemIndex itemHit)"},
+ {"IsDialogEvent", (PyCFunction)Dlg_IsDialogEvent, 1,
+ "(EventRecord theEvent) -> (Boolean _rv)"},
+ {"DialogSelect", (PyCFunction)Dlg_DialogSelect, 1,
+ "(EventRecord theEvent) -> (Boolean _rv, DialogPtr theDialog, DialogItemIndex itemHit)"},
+ {"Alert", (PyCFunction)Dlg_Alert, 1,
+ "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
+ {"StopAlert", (PyCFunction)Dlg_StopAlert, 1,
+ "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
+ {"NoteAlert", (PyCFunction)Dlg_NoteAlert, 1,
+ "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
+ {"CautionAlert", (PyCFunction)Dlg_CautionAlert, 1,
+ "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
+ {"ParamText", (PyCFunction)Dlg_ParamText, 1,
+ "(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None"},
+ {"GetDialogItemText", (PyCFunction)Dlg_GetDialogItemText, 1,
+ "(Handle item) -> (Str255 text)"},
+ {"SetDialogItemText", (PyCFunction)Dlg_SetDialogItemText, 1,
+ "(Handle item, Str255 text) -> None"},
+ {"GetAlertStage", (PyCFunction)Dlg_GetAlertStage, 1,
+ "() -> (SInt16 _rv)"},
+ {"SetDialogFont", (PyCFunction)Dlg_SetDialogFont, 1,
+ "(SInt16 fontNum) -> None"},
+ {"ResetAlertStage", (PyCFunction)Dlg_ResetAlertStage, 1,
+ "() -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"GetParamText", (PyCFunction)Dlg_GetParamText, 1,
+ "(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None"},
+#endif
+ {"NewFeaturesDialog", (PyCFunction)Dlg_NewFeaturesDialog, 1,
+ "(Rect inBoundsRect, Str255 inTitle, Boolean inIsVisible, SInt16 inProcID, WindowPtr inBehind, Boolean inGoAwayFlag, SInt32 inRefCon, Handle inItemListHandle, UInt32 inFlags) -> (DialogPtr _rv)"},
+ {"GetDialogFromWindow", (PyCFunction)Dlg_GetDialogFromWindow, 1,
+ "(WindowPtr window) -> (DialogPtr _rv)"},
+ {"SetUserItemHandler", (PyCFunction)Dlg_SetUserItemHandler, 1,
+ NULL},
+ {NULL, NULL, 0}
+};
+
+
+
+/* Return the WindowPtr corresponding to a DialogObject */
+#if 0
+WindowPtr
+DlgObj_ConvertToWindow(PyObject *self)
+{
+ if ( DlgObj_Check(self) )
+ return GetDialogWindow(((DialogObject *)self)->ob_itself);
+ return NULL;
+}
+#endif
+/* Return the object corresponding to the dialog, or None */
+
+PyObject *
+DlgObj_WhichDialog(DialogPtr d)
+{
+ PyObject *it;
+
+ if (d == NULL) {
+ it = Py_None;
+ Py_INCREF(it);
+ } else {
+ WindowPtr w = GetDialogWindow(d);
+
+ it = (PyObject *) GetWRefCon(w);
+ if (it == NULL || ((DialogObject *)it)->ob_itself != d || !DlgObj_Check(it)) {
+#if 0
+ /* Should do this, but we don't have an ob_freeit for dialogs yet. */
+ it = WinObj_New(w);
+ ((WindowObject *)it)->ob_freeit = NULL;
+#else
+ it = Py_None;
+ Py_INCREF(it);
+#endif
+ } else {
+ Py_INCREF(it);
+ }
+ }
+ return it;
+}
+
+
+void init_Dlg(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(DialogPtr, DlgObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(DialogPtr, DlgObj_WhichDialog);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(DialogPtr, DlgObj_Convert);
+
+
+ m = Py_InitModule("_Dlg", Dlg_methods);
+ d = PyModule_GetDict(m);
+ Dlg_Error = PyMac_GetOSErrException();
+ if (Dlg_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Dlg_Error) != 0)
+ return;
+ Dialog_Type.ob_type = &PyType_Type;
+ Py_INCREF(&Dialog_Type);
+ if (PyDict_SetItemString(d, "DialogType", (PyObject *)&Dialog_Type) != 0)
+ Py_FatalError("can't initialize DialogType");
+}
+
+/* ======================== End module _Dlg ========================= */
+
--- /dev/null
+
+/* ========================== Module _Drag ========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Drag.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+/* Callback glue routines */
+DragTrackingHandlerUPP dragglue_TrackingHandlerUPP;
+DragReceiveHandlerUPP dragglue_ReceiveHandlerUPP;
+DragSendDataUPP dragglue_SendDataUPP;
+#if 0
+DragInputUPP dragglue_InputUPP;
+DragDrawingUPP dragglue_DrawingUPP;
+#endif
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+extern PyObject *_DragObj_New(DragRef);
+extern int _DragObj_Convert(PyObject *, DragRef *);
+
+#define DragObj_New _DragObj_New
+#define DragObj_Convert _DragObj_Convert
+#endif
+
+static PyObject *Drag_Error;
+
+/* ---------------------- Object type DragObj ----------------------- */
+
+PyTypeObject DragObj_Type;
+
+#define DragObj_Check(x) ((x)->ob_type == &DragObj_Type)
+
+typedef struct DragObjObject {
+ PyObject_HEAD
+ DragRef ob_itself;
+ PyObject *sendproc;
+} DragObjObject;
+
+PyObject *DragObj_New(DragRef itself)
+{
+ DragObjObject *it;
+ if (itself == NULL) {
+ PyErr_SetString(Drag_Error,"Cannot create null Drag");
+ return NULL;
+ }
+ it = PyObject_NEW(DragObjObject, &DragObj_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->sendproc = NULL;
+ return (PyObject *)it;
+}
+DragObj_Convert(PyObject *v, DragRef *p_itself)
+{
+ if (!DragObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "DragObj required");
+ return 0;
+ }
+ *p_itself = ((DragObjObject *)v)->ob_itself;
+ return 1;
+}
+
+static void DragObj_dealloc(DragObjObject *self)
+{
+ Py_XDECREF(self->sendproc);
+ PyMem_DEL(self);
+}
+
+static PyObject *DragObj_DisposeDrag(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = DisposeDrag(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DragObj_AddDragItemFlavor(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ItemReference theItemRef;
+ FlavorType theType;
+ char *dataPtr__in__;
+ long dataPtr__len__;
+ int dataPtr__in_len__;
+ FlavorFlags theFlags;
+ if (!PyArg_ParseTuple(_args, "lO&z#l",
+ &theItemRef,
+ PyMac_GetOSType, &theType,
+ &dataPtr__in__, &dataPtr__in_len__,
+ &theFlags))
+ return NULL;
+ dataPtr__len__ = dataPtr__in_len__;
+ _err = AddDragItemFlavor(_self->ob_itself,
+ theItemRef,
+ theType,
+ dataPtr__in__, dataPtr__len__,
+ theFlags);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *DragObj_SetDragItemFlavorData(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ItemReference theItemRef;
+ FlavorType theType;
+ char *dataPtr__in__;
+ long dataPtr__len__;
+ int dataPtr__in_len__;
+ UInt32 dataOffset;
+ if (!PyArg_ParseTuple(_args, "lO&z#l",
+ &theItemRef,
+ PyMac_GetOSType, &theType,
+ &dataPtr__in__, &dataPtr__in_len__,
+ &dataOffset))
+ return NULL;
+ dataPtr__len__ = dataPtr__in_len__;
+ _err = SetDragItemFlavorData(_self->ob_itself,
+ theItemRef,
+ theType,
+ dataPtr__in__, dataPtr__len__,
+ dataOffset);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *DragObj_SetDragImage(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ PixMapHandle imagePixMap;
+ RgnHandle imageRgn;
+ Point imageOffsetPt;
+ DragImageFlags theImageFlags;
+ if (!PyArg_ParseTuple(_args, "O&O&O&l",
+ ResObj_Convert, &imagePixMap,
+ ResObj_Convert, &imageRgn,
+ PyMac_GetPoint, &imageOffsetPt,
+ &theImageFlags))
+ return NULL;
+ _err = SetDragImage(_self->ob_itself,
+ imagePixMap,
+ imageRgn,
+ imageOffsetPt,
+ theImageFlags);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DragObj_ChangeDragBehaviors(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ DragBehaviors inBehaviorsToSet;
+ DragBehaviors inBehaviorsToClear;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &inBehaviorsToSet,
+ &inBehaviorsToClear))
+ return NULL;
+ _err = ChangeDragBehaviors(_self->ob_itself,
+ inBehaviorsToSet,
+ inBehaviorsToClear);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DragObj_TrackDrag(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ EventRecord theEvent;
+ RgnHandle theRegion;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetEventRecord, &theEvent,
+ ResObj_Convert, &theRegion))
+ return NULL;
+ _err = TrackDrag(_self->ob_itself,
+ &theEvent,
+ theRegion);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DragObj_CountDragItems(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ UInt16 numItems;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = CountDragItems(_self->ob_itself,
+ &numItems);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("H",
+ numItems);
+ return _res;
+}
+
+static PyObject *DragObj_GetDragItemReferenceNumber(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ UInt16 index;
+ ItemReference theItemRef;
+ if (!PyArg_ParseTuple(_args, "H",
+ &index))
+ return NULL;
+ _err = GetDragItemReferenceNumber(_self->ob_itself,
+ index,
+ &theItemRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ theItemRef);
+ return _res;
+}
+
+static PyObject *DragObj_CountDragItemFlavors(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ItemReference theItemRef;
+ UInt16 numFlavors;
+ if (!PyArg_ParseTuple(_args, "l",
+ &theItemRef))
+ return NULL;
+ _err = CountDragItemFlavors(_self->ob_itself,
+ theItemRef,
+ &numFlavors);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("H",
+ numFlavors);
+ return _res;
+}
+
+static PyObject *DragObj_GetFlavorType(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ItemReference theItemRef;
+ UInt16 index;
+ FlavorType theType;
+ if (!PyArg_ParseTuple(_args, "lH",
+ &theItemRef,
+ &index))
+ return NULL;
+ _err = GetFlavorType(_self->ob_itself,
+ theItemRef,
+ index,
+ &theType);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildOSType, theType);
+ return _res;
+}
+
+static PyObject *DragObj_GetFlavorFlags(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ItemReference theItemRef;
+ FlavorType theType;
+ FlavorFlags theFlags;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &theItemRef,
+ PyMac_GetOSType, &theType))
+ return NULL;
+ _err = GetFlavorFlags(_self->ob_itself,
+ theItemRef,
+ theType,
+ &theFlags);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ theFlags);
+ return _res;
+}
+
+static PyObject *DragObj_GetFlavorDataSize(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ItemReference theItemRef;
+ FlavorType theType;
+ Size dataSize;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &theItemRef,
+ PyMac_GetOSType, &theType))
+ return NULL;
+ _err = GetFlavorDataSize(_self->ob_itself,
+ theItemRef,
+ theType,
+ &dataSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ dataSize);
+ return _res;
+}
+
+static PyObject *DragObj_GetFlavorData(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ItemReference theItemRef;
+ FlavorType theType;
+ char *dataPtr__out__;
+ long dataPtr__len__;
+ int dataPtr__in_len__;
+ UInt32 dataOffset;
+ if (!PyArg_ParseTuple(_args, "lO&il",
+ &theItemRef,
+ PyMac_GetOSType, &theType,
+ &dataPtr__in_len__,
+ &dataOffset))
+ return NULL;
+ if ((dataPtr__out__ = malloc(dataPtr__in_len__)) == NULL)
+ {
+ PyErr_NoMemory();
+ goto dataPtr__error__;
+ }
+ dataPtr__len__ = dataPtr__in_len__;
+ _err = GetFlavorData(_self->ob_itself,
+ theItemRef,
+ theType,
+ dataPtr__out__, &dataPtr__len__,
+ dataOffset);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("s#",
+ dataPtr__out__, (int)dataPtr__len__);
+ free(dataPtr__out__);
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *DragObj_GetDragItemBounds(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ItemReference theItemRef;
+ Rect itemBounds;
+ if (!PyArg_ParseTuple(_args, "l",
+ &theItemRef))
+ return NULL;
+ _err = GetDragItemBounds(_self->ob_itself,
+ theItemRef,
+ &itemBounds);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &itemBounds);
+ return _res;
+}
+
+static PyObject *DragObj_SetDragItemBounds(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ ItemReference theItemRef;
+ Rect itemBounds;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &theItemRef,
+ PyMac_GetRect, &itemBounds))
+ return NULL;
+ _err = SetDragItemBounds(_self->ob_itself,
+ theItemRef,
+ &itemBounds);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DragObj_GetDropLocation(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEDesc dropLocation;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetDropLocation(_self->ob_itself,
+ &dropLocation);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ AEDesc_New, &dropLocation);
+ return _res;
+}
+
+static PyObject *DragObj_SetDropLocation(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEDesc dropLocation;
+ if (!PyArg_ParseTuple(_args, "O&",
+ AEDesc_Convert, &dropLocation))
+ return NULL;
+ _err = SetDropLocation(_self->ob_itself,
+ &dropLocation);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DragObj_GetDragAttributes(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ DragAttributes flags;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetDragAttributes(_self->ob_itself,
+ &flags);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ flags);
+ return _res;
+}
+
+static PyObject *DragObj_GetDragMouse(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Point mouse;
+ Point globalPinnedMouse;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetDragMouse(_self->ob_itself,
+ &mouse,
+ &globalPinnedMouse);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&",
+ PyMac_BuildPoint, mouse,
+ PyMac_BuildPoint, globalPinnedMouse);
+ return _res;
+}
+
+static PyObject *DragObj_SetDragMouse(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Point globalPinnedMouse;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &globalPinnedMouse))
+ return NULL;
+ _err = SetDragMouse(_self->ob_itself,
+ globalPinnedMouse);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DragObj_GetDragOrigin(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Point globalInitialMouse;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetDragOrigin(_self->ob_itself,
+ &globalInitialMouse);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, globalInitialMouse);
+ return _res;
+}
+
+static PyObject *DragObj_GetDragModifiers(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 modifiers;
+ SInt16 mouseDownModifiers;
+ SInt16 mouseUpModifiers;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetDragModifiers(_self->ob_itself,
+ &modifiers,
+ &mouseDownModifiers,
+ &mouseUpModifiers);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("hhh",
+ modifiers,
+ mouseDownModifiers,
+ mouseUpModifiers);
+ return _res;
+}
+
+static PyObject *DragObj_ShowDragHilite(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ RgnHandle hiliteFrame;
+ Boolean inside;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ ResObj_Convert, &hiliteFrame,
+ &inside))
+ return NULL;
+ _err = ShowDragHilite(_self->ob_itself,
+ hiliteFrame,
+ inside);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DragObj_HideDragHilite(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = HideDragHilite(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DragObj_DragPreScroll(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 dH;
+ SInt16 dV;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &dH,
+ &dV))
+ return NULL;
+ _err = DragPreScroll(_self->ob_itself,
+ dH,
+ dV);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DragObj_DragPostScroll(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = DragPostScroll(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DragObj_UpdateDragHilite(DragObjObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ RgnHandle updateRgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &updateRgn))
+ return NULL;
+ _err = UpdateDragHilite(_self->ob_itself,
+ updateRgn);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef DragObj_methods[] = {
+ {"DisposeDrag", (PyCFunction)DragObj_DisposeDrag, 1,
+ "() -> None"},
+ {"AddDragItemFlavor", (PyCFunction)DragObj_AddDragItemFlavor, 1,
+ "(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, FlavorFlags theFlags) -> None"},
+ {"SetDragItemFlavorData", (PyCFunction)DragObj_SetDragItemFlavorData, 1,
+ "(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> None"},
+ {"SetDragImage", (PyCFunction)DragObj_SetDragImage, 1,
+ "(PixMapHandle imagePixMap, RgnHandle imageRgn, Point imageOffsetPt, DragImageFlags theImageFlags) -> None"},
+ {"ChangeDragBehaviors", (PyCFunction)DragObj_ChangeDragBehaviors, 1,
+ "(DragBehaviors inBehaviorsToSet, DragBehaviors inBehaviorsToClear) -> None"},
+ {"TrackDrag", (PyCFunction)DragObj_TrackDrag, 1,
+ "(EventRecord theEvent, RgnHandle theRegion) -> None"},
+ {"CountDragItems", (PyCFunction)DragObj_CountDragItems, 1,
+ "() -> (UInt16 numItems)"},
+ {"GetDragItemReferenceNumber", (PyCFunction)DragObj_GetDragItemReferenceNumber, 1,
+ "(UInt16 index) -> (ItemReference theItemRef)"},
+ {"CountDragItemFlavors", (PyCFunction)DragObj_CountDragItemFlavors, 1,
+ "(ItemReference theItemRef) -> (UInt16 numFlavors)"},
+ {"GetFlavorType", (PyCFunction)DragObj_GetFlavorType, 1,
+ "(ItemReference theItemRef, UInt16 index) -> (FlavorType theType)"},
+ {"GetFlavorFlags", (PyCFunction)DragObj_GetFlavorFlags, 1,
+ "(ItemReference theItemRef, FlavorType theType) -> (FlavorFlags theFlags)"},
+ {"GetFlavorDataSize", (PyCFunction)DragObj_GetFlavorDataSize, 1,
+ "(ItemReference theItemRef, FlavorType theType) -> (Size dataSize)"},
+ {"GetFlavorData", (PyCFunction)DragObj_GetFlavorData, 1,
+ "(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> (Buffer dataPtr)"},
+ {"GetDragItemBounds", (PyCFunction)DragObj_GetDragItemBounds, 1,
+ "(ItemReference theItemRef) -> (Rect itemBounds)"},
+ {"SetDragItemBounds", (PyCFunction)DragObj_SetDragItemBounds, 1,
+ "(ItemReference theItemRef, Rect itemBounds) -> None"},
+ {"GetDropLocation", (PyCFunction)DragObj_GetDropLocation, 1,
+ "() -> (AEDesc dropLocation)"},
+ {"SetDropLocation", (PyCFunction)DragObj_SetDropLocation, 1,
+ "(AEDesc dropLocation) -> None"},
+ {"GetDragAttributes", (PyCFunction)DragObj_GetDragAttributes, 1,
+ "() -> (DragAttributes flags)"},
+ {"GetDragMouse", (PyCFunction)DragObj_GetDragMouse, 1,
+ "() -> (Point mouse, Point globalPinnedMouse)"},
+ {"SetDragMouse", (PyCFunction)DragObj_SetDragMouse, 1,
+ "(Point globalPinnedMouse) -> None"},
+ {"GetDragOrigin", (PyCFunction)DragObj_GetDragOrigin, 1,
+ "() -> (Point globalInitialMouse)"},
+ {"GetDragModifiers", (PyCFunction)DragObj_GetDragModifiers, 1,
+ "() -> (SInt16 modifiers, SInt16 mouseDownModifiers, SInt16 mouseUpModifiers)"},
+ {"ShowDragHilite", (PyCFunction)DragObj_ShowDragHilite, 1,
+ "(RgnHandle hiliteFrame, Boolean inside) -> None"},
+ {"HideDragHilite", (PyCFunction)DragObj_HideDragHilite, 1,
+ "() -> None"},
+ {"DragPreScroll", (PyCFunction)DragObj_DragPreScroll, 1,
+ "(SInt16 dH, SInt16 dV) -> None"},
+ {"DragPostScroll", (PyCFunction)DragObj_DragPostScroll, 1,
+ "() -> None"},
+ {"UpdateDragHilite", (PyCFunction)DragObj_UpdateDragHilite, 1,
+ "(RgnHandle updateRgn) -> None"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain DragObj_chain = { DragObj_methods, NULL };
+
+static PyObject *DragObj_getattr(DragObjObject *self, char *name)
+{
+ return Py_FindMethodInChain(&DragObj_chain, (PyObject *)self, name);
+}
+
+#define DragObj_setattr NULL
+
+#define DragObj_compare NULL
+
+#define DragObj_repr NULL
+
+#define DragObj_hash NULL
+
+PyTypeObject DragObj_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "DragObj", /*tp_name*/
+ sizeof(DragObjObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) DragObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) DragObj_getattr, /*tp_getattr*/
+ (setattrfunc) DragObj_setattr, /*tp_setattr*/
+ (cmpfunc) DragObj_compare, /*tp_compare*/
+ (reprfunc) DragObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) DragObj_hash, /*tp_hash*/
+};
+
+/* -------------------- End object type DragObj --------------------- */
+
+
+static PyObject *Drag_NewDrag(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ DragRef theDrag;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = NewDrag(&theDrag);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ DragObj_New, theDrag);
+ return _res;
+}
+
+static PyObject *Drag_GetDragHiliteColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ WindowPtr window;
+ RGBColor color;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &window))
+ return NULL;
+ _err = GetDragHiliteColor(window,
+ &color);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &color);
+ return _res;
+}
+
+static PyObject *Drag_WaitMouseMoved(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point initialMouse;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &initialMouse))
+ return NULL;
+ _rv = WaitMouseMoved(initialMouse);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Drag_ZoomRects(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Rect fromRect;
+ Rect toRect;
+ SInt16 zoomSteps;
+ ZoomAcceleration acceleration;
+ if (!PyArg_ParseTuple(_args, "O&O&hh",
+ PyMac_GetRect, &fromRect,
+ PyMac_GetRect, &toRect,
+ &zoomSteps,
+ &acceleration))
+ return NULL;
+ _err = ZoomRects(&fromRect,
+ &toRect,
+ zoomSteps,
+ acceleration);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Drag_ZoomRegion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ RgnHandle region;
+ Point zoomDistance;
+ SInt16 zoomSteps;
+ ZoomAcceleration acceleration;
+ if (!PyArg_ParseTuple(_args, "O&O&hh",
+ ResObj_Convert, ®ion,
+ PyMac_GetPoint, &zoomDistance,
+ &zoomSteps,
+ &acceleration))
+ return NULL;
+ _err = ZoomRegion(region,
+ zoomDistance,
+ zoomSteps,
+ acceleration);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Drag_InstallTrackingHandler(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ PyObject *callback;
+ WindowPtr theWindow = NULL;
+ OSErr _err;
+
+ if ( !PyArg_ParseTuple(_args, "O|O&", &callback, WinObj_Convert, &theWindow) )
+ return NULL;
+ Py_INCREF(callback); /* Cannot decref later, too bad */
+ _err = InstallTrackingHandler(dragglue_TrackingHandlerUPP, theWindow, (void *)callback);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ return Py_None;
+
+}
+
+static PyObject *Drag_InstallReceiveHandler(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ PyObject *callback;
+ WindowPtr theWindow = NULL;
+ OSErr _err;
+
+ if ( !PyArg_ParseTuple(_args, "O|O&", &callback, WinObj_Convert, &theWindow) )
+ return NULL;
+ Py_INCREF(callback); /* Cannot decref later, too bad */
+ _err = InstallReceiveHandler(dragglue_ReceiveHandlerUPP, theWindow, (void *)callback);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ return Py_None;
+
+}
+
+static PyObject *Drag_RemoveTrackingHandler(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ WindowPtr theWindow = NULL;
+ OSErr _err;
+
+ if ( !PyArg_ParseTuple(_args, "|O&", WinObj_Convert, &theWindow) )
+ return NULL;
+ _err = RemoveTrackingHandler(dragglue_TrackingHandlerUPP, theWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ return Py_None;
+
+}
+
+static PyObject *Drag_RemoveReceiveHandler(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ WindowPtr theWindow = NULL;
+ OSErr _err;
+
+ if ( !PyArg_ParseTuple(_args, "|O&", WinObj_Convert, &theWindow) )
+ return NULL;
+ _err = RemoveReceiveHandler(dragglue_ReceiveHandlerUPP, theWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ return Py_None;
+
+}
+
+static PyMethodDef Drag_methods[] = {
+ {"NewDrag", (PyCFunction)Drag_NewDrag, 1,
+ "() -> (DragRef theDrag)"},
+ {"GetDragHiliteColor", (PyCFunction)Drag_GetDragHiliteColor, 1,
+ "(WindowPtr window) -> (RGBColor color)"},
+ {"WaitMouseMoved", (PyCFunction)Drag_WaitMouseMoved, 1,
+ "(Point initialMouse) -> (Boolean _rv)"},
+ {"ZoomRects", (PyCFunction)Drag_ZoomRects, 1,
+ "(Rect fromRect, Rect toRect, SInt16 zoomSteps, ZoomAcceleration acceleration) -> None"},
+ {"ZoomRegion", (PyCFunction)Drag_ZoomRegion, 1,
+ "(RgnHandle region, Point zoomDistance, SInt16 zoomSteps, ZoomAcceleration acceleration) -> None"},
+ {"InstallTrackingHandler", (PyCFunction)Drag_InstallTrackingHandler, 1,
+ NULL},
+ {"InstallReceiveHandler", (PyCFunction)Drag_InstallReceiveHandler, 1,
+ NULL},
+ {"RemoveTrackingHandler", (PyCFunction)Drag_RemoveTrackingHandler, 1,
+ NULL},
+ {"RemoveReceiveHandler", (PyCFunction)Drag_RemoveReceiveHandler, 1,
+ NULL},
+ {NULL, NULL, 0}
+};
+
+
+
+static pascal OSErr
+dragglue_TrackingHandler(DragTrackingMessage theMessage, WindowPtr theWindow,
+ void *handlerRefCon, DragReference theDrag)
+{
+ PyObject *args, *rv;
+ int i;
+
+ args = Py_BuildValue("hO&O&", theMessage, DragObj_New, theDrag, WinObj_WhichWindow, theWindow);
+ if ( args == NULL )
+ return -1;
+ rv = PyEval_CallObject((PyObject *)handlerRefCon, args);
+ Py_DECREF(args);
+ if ( rv == NULL ) {
+ fprintf(stderr, "Drag: Exception in TrackingHandler\n");
+ return -1;
+ }
+ i = -1;
+ if ( rv == Py_None )
+ i = 0;
+ else
+ PyArg_Parse(rv, "l", &i);
+ Py_DECREF(rv);
+ return i;
+}
+
+static pascal OSErr
+dragglue_ReceiveHandler(WindowPtr theWindow, void *handlerRefCon,
+ DragReference theDrag)
+{
+ PyObject *args, *rv;
+ int i;
+
+ args = Py_BuildValue("O&O&", DragObj_New, theDrag, WinObj_WhichWindow, theWindow);
+ if ( args == NULL )
+ return -1;
+ rv = PyEval_CallObject((PyObject *)handlerRefCon, args);
+ Py_DECREF(args);
+ if ( rv == NULL ) {
+ fprintf(stderr, "Drag: Exception in ReceiveHandler\n");
+ return -1;
+ }
+ i = -1;
+ if ( rv == Py_None )
+ i = 0;
+ else
+ PyArg_Parse(rv, "l", &i);
+ Py_DECREF(rv);
+ return i;
+}
+
+static pascal OSErr
+dragglue_SendData(FlavorType theType, void *dragSendRefCon,
+ ItemReference theItem, DragReference theDrag)
+{
+ DragObjObject *self = (DragObjObject *)dragSendRefCon;
+ PyObject *args, *rv;
+ int i;
+
+ if ( self->sendproc == NULL )
+ return -1;
+ args = Py_BuildValue("O&l", PyMac_BuildOSType, theType, theItem);
+ if ( args == NULL )
+ return -1;
+ rv = PyEval_CallObject(self->sendproc, args);
+ Py_DECREF(args);
+ if ( rv == NULL ) {
+ fprintf(stderr, "Drag: Exception in SendDataHandler\n");
+ return -1;
+ }
+ i = -1;
+ if ( rv == Py_None )
+ i = 0;
+ else
+ PyArg_Parse(rv, "l", &i);
+ Py_DECREF(rv);
+ return i;
+}
+
+#if 0
+static pascal OSErr
+dragglue_Input(Point *mouse, short *modifiers,
+ void *dragSendRefCon, DragReference theDrag)
+{
+ return 0;
+}
+
+static pascal OSErr
+dragglue_Drawing(xxxx
+ void *dragSendRefCon, DragReference theDrag)
+{
+ return 0;
+}
+#endif
+
+
+
+void init_Drag(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(DragRef, DragObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(DragRef, DragObj_Convert);
+
+
+ m = Py_InitModule("_Drag", Drag_methods);
+ d = PyModule_GetDict(m);
+ Drag_Error = PyMac_GetOSErrException();
+ if (Drag_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Drag_Error) != 0)
+ return;
+ DragObj_Type.ob_type = &PyType_Type;
+ Py_INCREF(&DragObj_Type);
+ if (PyDict_SetItemString(d, "DragObjType", (PyObject *)&DragObj_Type) != 0)
+ Py_FatalError("can't initialize DragObjType");
+
+ dragglue_TrackingHandlerUPP = NewDragTrackingHandlerUPP(dragglue_TrackingHandler);
+ dragglue_ReceiveHandlerUPP = NewDragReceiveHandlerUPP(dragglue_ReceiveHandler);
+ dragglue_SendDataUPP = NewDragSendDataUPP(dragglue_SendData);
+#if 0
+ dragglue_InputUPP = NewDragInputUPP(dragglue_Input);
+ dragglue_DrawingUPP = NewDragDrawingUPP(dragglue_Drawing);
+#endif
+
+
+}
+
+/* ======================== End module _Drag ======================== */
+
--- /dev/null
+
+/* ========================== Module _Evt =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Events.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+
+static PyObject *Evt_Error;
+
+static PyObject *Evt_GetMouse(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point mouseLoc;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetMouse(&mouseLoc);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, mouseLoc);
+ return _res;
+}
+
+static PyObject *Evt_Button(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = Button();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Evt_StillDown(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = StillDown();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Evt_WaitMouseUp(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = WaitMouseUp();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Evt_TickCount(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt32 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TickCount();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Evt_GetCaretTime(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt32 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetCaretTime();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Evt_GetKeys(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ KeyMap theKeys__out__;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetKeys(theKeys__out__);
+ _res = Py_BuildValue("s#",
+ (char *)&theKeys__out__, (int)sizeof(KeyMap));
+ theKeys__error__: ;
+ return _res;
+}
+
+static PyObject *Evt_GetDblTime(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt32 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetDblTime();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Evt_SetEventMask(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ EventMask value;
+ if (!PyArg_ParseTuple(_args, "H",
+ &value))
+ return NULL;
+ SetEventMask(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Evt_GetNextEvent(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventMask eventMask;
+ EventRecord theEvent;
+ if (!PyArg_ParseTuple(_args, "H",
+ &eventMask))
+ return NULL;
+ _rv = GetNextEvent(eventMask,
+ &theEvent);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildEventRecord, &theEvent);
+ return _res;
+}
+
+static PyObject *Evt_EventAvail(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventMask eventMask;
+ EventRecord theEvent;
+ if (!PyArg_ParseTuple(_args, "H",
+ &eventMask))
+ return NULL;
+ _rv = EventAvail(eventMask,
+ &theEvent);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildEventRecord, &theEvent);
+ return _res;
+}
+
+static PyObject *Evt_PostEvent(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ EventKind eventNum;
+ UInt32 eventMsg;
+ if (!PyArg_ParseTuple(_args, "Hl",
+ &eventNum,
+ &eventMsg))
+ return NULL;
+ _err = PostEvent(eventNum,
+ eventMsg);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Evt_OSEventAvail(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventMask mask;
+ EventRecord theEvent;
+ if (!PyArg_ParseTuple(_args, "H",
+ &mask))
+ return NULL;
+ _rv = OSEventAvail(mask,
+ &theEvent);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildEventRecord, &theEvent);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Evt_GetOSEvent(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventMask mask;
+ EventRecord theEvent;
+ if (!PyArg_ParseTuple(_args, "H",
+ &mask))
+ return NULL;
+ _rv = GetOSEvent(mask,
+ &theEvent);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildEventRecord, &theEvent);
+ return _res;
+}
+#endif
+
+static PyObject *Evt_FlushEvents(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ EventMask whichMask;
+ EventMask stopMask;
+ if (!PyArg_ParseTuple(_args, "HH",
+ &whichMask,
+ &stopMask))
+ return NULL;
+ FlushEvents(whichMask,
+ stopMask);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Evt_SystemClick(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ EventRecord theEvent;
+ WindowPtr theWindow;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetEventRecord, &theEvent,
+ WinObj_Convert, &theWindow))
+ return NULL;
+ SystemClick(&theEvent,
+ theWindow);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Evt_SystemTask(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ SystemTask();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Evt_SystemEvent(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventRecord theEvent;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &theEvent))
+ return NULL;
+ _rv = SystemEvent(&theEvent);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Evt_GetGlobalMouse(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point globalMouse;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetGlobalMouse(&globalMouse);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, globalMouse);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Evt_GetCurrentKeyModifiers(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt32 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetCurrentKeyModifiers();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Evt_CheckEventQueueForUserCancel(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CheckEventQueueForUserCancel();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *Evt_WaitNextEvent(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ Boolean _rv;
+ EventMask eventMask;
+ EventRecord theEvent;
+ UInt32 sleep;
+ Handle mouseregion = (Handle)0;
+
+ if (!PyArg_ParseTuple(_args, "Hl|O&",
+ &eventMask,
+ &sleep,
+ OptResObj_Convert, &mouseregion))
+ return NULL;
+ _rv = WaitNextEvent(eventMask,
+ &theEvent,
+ sleep,
+ (RgnHandle)mouseregion);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildEventRecord, &theEvent);
+ return _res;
+
+}
+
+static PyMethodDef Evt_methods[] = {
+ {"GetMouse", (PyCFunction)Evt_GetMouse, 1,
+ "() -> (Point mouseLoc)"},
+ {"Button", (PyCFunction)Evt_Button, 1,
+ "() -> (Boolean _rv)"},
+ {"StillDown", (PyCFunction)Evt_StillDown, 1,
+ "() -> (Boolean _rv)"},
+ {"WaitMouseUp", (PyCFunction)Evt_WaitMouseUp, 1,
+ "() -> (Boolean _rv)"},
+ {"TickCount", (PyCFunction)Evt_TickCount, 1,
+ "() -> (UInt32 _rv)"},
+ {"GetCaretTime", (PyCFunction)Evt_GetCaretTime, 1,
+ "() -> (UInt32 _rv)"},
+ {"GetKeys", (PyCFunction)Evt_GetKeys, 1,
+ "() -> (KeyMap theKeys)"},
+ {"GetDblTime", (PyCFunction)Evt_GetDblTime, 1,
+ "() -> (UInt32 _rv)"},
+ {"SetEventMask", (PyCFunction)Evt_SetEventMask, 1,
+ "(EventMask value) -> None"},
+ {"GetNextEvent", (PyCFunction)Evt_GetNextEvent, 1,
+ "(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)"},
+ {"EventAvail", (PyCFunction)Evt_EventAvail, 1,
+ "(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)"},
+ {"PostEvent", (PyCFunction)Evt_PostEvent, 1,
+ "(EventKind eventNum, UInt32 eventMsg) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+ {"OSEventAvail", (PyCFunction)Evt_OSEventAvail, 1,
+ "(EventMask mask) -> (Boolean _rv, EventRecord theEvent)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"GetOSEvent", (PyCFunction)Evt_GetOSEvent, 1,
+ "(EventMask mask) -> (Boolean _rv, EventRecord theEvent)"},
+#endif
+ {"FlushEvents", (PyCFunction)Evt_FlushEvents, 1,
+ "(EventMask whichMask, EventMask stopMask) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+ {"SystemClick", (PyCFunction)Evt_SystemClick, 1,
+ "(EventRecord theEvent, WindowPtr theWindow) -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"SystemTask", (PyCFunction)Evt_SystemTask, 1,
+ "() -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"SystemEvent", (PyCFunction)Evt_SystemEvent, 1,
+ "(EventRecord theEvent) -> (Boolean _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetGlobalMouse", (PyCFunction)Evt_GetGlobalMouse, 1,
+ "() -> (Point globalMouse)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetCurrentKeyModifiers", (PyCFunction)Evt_GetCurrentKeyModifiers, 1,
+ "() -> (UInt32 _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"CheckEventQueueForUserCancel", (PyCFunction)Evt_CheckEventQueueForUserCancel, 1,
+ "() -> (Boolean _rv)"},
+#endif
+ {"WaitNextEvent", (PyCFunction)Evt_WaitNextEvent, 1,
+ "(EventMask eventMask, UInt32 sleep [,RegionHandle]) -> (Boolean _rv, EventRecord theEvent)"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_Evt(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+ m = Py_InitModule("_Evt", Evt_methods);
+ d = PyModule_GetDict(m);
+ Evt_Error = PyMac_GetOSErrException();
+ if (Evt_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Evt_Error) != 0)
+ return;
+}
+
+/* ======================== End module _Evt ========================= */
+
--- /dev/null
+
+/* =========================== Module _Fm =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Fonts.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+
+/*
+** Parse/generate ComponentDescriptor records
+*/
+static PyObject *
+FMRec_New(FMetricRec *itself)
+{
+
+ return Py_BuildValue("O&O&O&O&O&",
+ PyMac_BuildFixed, itself->ascent,
+ PyMac_BuildFixed, itself->descent,
+ PyMac_BuildFixed, itself->leading,
+ PyMac_BuildFixed, itself->widMax,
+ ResObj_New, itself->wTabHandle);
+}
+
+#if 0
+/* Not needed... */
+static int
+FMRec_Convert(PyObject *v, FMetricRec *p_itself)
+{
+ return PyArg_ParseTuple(v, "O&O&O&O&O&",
+ PyMac_GetFixed, &itself->ascent,
+ PyMac_GetFixed, &itself->descent,
+ PyMac_GetFixed, &itself->leading,
+ PyMac_GetFixed, &itself->widMax,
+ ResObj_Convert, &itself->wTabHandle);
+}
+#endif
+
+
+static PyObject *Fm_Error;
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Fm_InitFonts(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ InitFonts();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Fm_GetFontName(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short familyID;
+ Str255 name;
+ if (!PyArg_ParseTuple(_args, "h",
+ &familyID))
+ return NULL;
+ GetFontName(familyID,
+ name);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildStr255, name);
+ return _res;
+}
+
+static PyObject *Fm_GetFNum(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Str255 name;
+ short familyID;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, name))
+ return NULL;
+ GetFNum(name,
+ &familyID);
+ _res = Py_BuildValue("h",
+ familyID);
+ return _res;
+}
+
+static PyObject *Fm_RealFont(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ short fontNum;
+ short size;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &fontNum,
+ &size))
+ return NULL;
+ _rv = RealFont(fontNum,
+ size);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Fm_SetFontLock(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean lockFlag;
+ if (!PyArg_ParseTuple(_args, "b",
+ &lockFlag))
+ return NULL;
+ SetFontLock(lockFlag);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Fm_SetFScaleDisable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean fscaleDisable;
+ if (!PyArg_ParseTuple(_args, "b",
+ &fscaleDisable))
+ return NULL;
+ SetFScaleDisable(fscaleDisable);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Fm_FontMetrics(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ FMetricRec theMetrics;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ FontMetrics(&theMetrics);
+ _res = Py_BuildValue("O&",
+ FMRec_New, &theMetrics);
+ return _res;
+}
+
+static PyObject *Fm_SetFractEnable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean fractEnable;
+ if (!PyArg_ParseTuple(_args, "b",
+ &fractEnable))
+ return NULL;
+ SetFractEnable(fractEnable);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Fm_GetDefFontSize(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetDefFontSize();
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Fm_IsOutline(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point numer;
+ Point denom;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &numer,
+ PyMac_GetPoint, &denom))
+ return NULL;
+ _rv = IsOutline(numer,
+ denom);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Fm_SetOutlinePreferred(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean outlinePreferred;
+ if (!PyArg_ParseTuple(_args, "b",
+ &outlinePreferred))
+ return NULL;
+ SetOutlinePreferred(outlinePreferred);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Fm_GetOutlinePreferred(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetOutlinePreferred();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Fm_SetPreserveGlyph(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean preserveGlyph;
+ if (!PyArg_ParseTuple(_args, "b",
+ &preserveGlyph))
+ return NULL;
+ SetPreserveGlyph(preserveGlyph);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Fm_GetPreserveGlyph(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetPreserveGlyph();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Fm_FlushFonts(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = FlushFonts();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Fm_GetSysFont(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetSysFont();
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Fm_GetAppFont(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetAppFont();
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyMethodDef Fm_methods[] = {
+
+#if !TARGET_API_MAC_CARBON
+ {"InitFonts", (PyCFunction)Fm_InitFonts, 1,
+ "() -> None"},
+#endif
+ {"GetFontName", (PyCFunction)Fm_GetFontName, 1,
+ "(short familyID) -> (Str255 name)"},
+ {"GetFNum", (PyCFunction)Fm_GetFNum, 1,
+ "(Str255 name) -> (short familyID)"},
+ {"RealFont", (PyCFunction)Fm_RealFont, 1,
+ "(short fontNum, short size) -> (Boolean _rv)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"SetFontLock", (PyCFunction)Fm_SetFontLock, 1,
+ "(Boolean lockFlag) -> None"},
+#endif
+ {"SetFScaleDisable", (PyCFunction)Fm_SetFScaleDisable, 1,
+ "(Boolean fscaleDisable) -> None"},
+ {"FontMetrics", (PyCFunction)Fm_FontMetrics, 1,
+ "() -> (FMetricRec theMetrics)"},
+ {"SetFractEnable", (PyCFunction)Fm_SetFractEnable, 1,
+ "(Boolean fractEnable) -> None"},
+ {"GetDefFontSize", (PyCFunction)Fm_GetDefFontSize, 1,
+ "() -> (short _rv)"},
+ {"IsOutline", (PyCFunction)Fm_IsOutline, 1,
+ "(Point numer, Point denom) -> (Boolean _rv)"},
+ {"SetOutlinePreferred", (PyCFunction)Fm_SetOutlinePreferred, 1,
+ "(Boolean outlinePreferred) -> None"},
+ {"GetOutlinePreferred", (PyCFunction)Fm_GetOutlinePreferred, 1,
+ "() -> (Boolean _rv)"},
+ {"SetPreserveGlyph", (PyCFunction)Fm_SetPreserveGlyph, 1,
+ "(Boolean preserveGlyph) -> None"},
+ {"GetPreserveGlyph", (PyCFunction)Fm_GetPreserveGlyph, 1,
+ "() -> (Boolean _rv)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"FlushFonts", (PyCFunction)Fm_FlushFonts, 1,
+ "() -> None"},
+#endif
+ {"GetSysFont", (PyCFunction)Fm_GetSysFont, 1,
+ "() -> (short _rv)"},
+ {"GetAppFont", (PyCFunction)Fm_GetAppFont, 1,
+ "() -> (short _rv)"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_Fm(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+ m = Py_InitModule("_Fm", Fm_methods);
+ d = PyModule_GetDict(m);
+ Fm_Error = PyMac_GetOSErrException();
+ if (Fm_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Fm_Error) != 0)
+ return;
+}
+
+/* ========================= End module _Fm ========================= */
+
--- /dev/null
+
+/* ========================== Module _Help ========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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 <Balloons.h>
+
+static PyObject *Help_Error;
+
+static PyObject *Help_HMGetHelpMenuHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ MenuHandle mh;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = HMGetHelpMenuHandle(&mh);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, mh);
+ return _res;
+}
+
+static PyObject *Help_HMRemoveBalloon(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = HMRemoveBalloon();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Help_HMIsBalloon(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = HMIsBalloon();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Help_HMGetBalloons(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = HMGetBalloons();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Help_HMSetBalloons(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Boolean flag;
+ if (!PyArg_ParseTuple(_args, "b",
+ &flag))
+ return NULL;
+ _err = HMSetBalloons(flag);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Help_HMSetFont(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 font;
+ if (!PyArg_ParseTuple(_args, "h",
+ &font))
+ return NULL;
+ _err = HMSetFont(font);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Help_HMSetFontSize(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ UInt16 fontSize;
+ if (!PyArg_ParseTuple(_args, "H",
+ &fontSize))
+ return NULL;
+ _err = HMSetFontSize(fontSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Help_HMGetFont(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 font;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = HMGetFont(&font);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ font);
+ return _res;
+}
+
+static PyObject *Help_HMGetFontSize(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ UInt16 fontSize;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = HMGetFontSize(&fontSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("H",
+ fontSize);
+ return _res;
+}
+
+static PyObject *Help_HMSetDialogResID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 resID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &resID))
+ return NULL;
+ _err = HMSetDialogResID(resID);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Help_HMSetMenuResID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 menuID;
+ SInt16 resID;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &menuID,
+ &resID))
+ return NULL;
+ _err = HMSetMenuResID(menuID,
+ resID);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Help_HMScanTemplateItems(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 whichID;
+ SInt16 whichResFile;
+ ResType whichType;
+ if (!PyArg_ParseTuple(_args, "hhO&",
+ &whichID,
+ &whichResFile,
+ PyMac_GetOSType, &whichType))
+ return NULL;
+ _err = HMScanTemplateItems(whichID,
+ whichResFile,
+ whichType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Help_HMGetDialogResID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 resID;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = HMGetDialogResID(&resID);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ resID);
+ return _res;
+}
+
+static PyObject *Help_HMGetMenuResID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 menuID;
+ SInt16 resID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &menuID))
+ return NULL;
+ _err = HMGetMenuResID(menuID,
+ &resID);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ resID);
+ return _res;
+}
+
+static PyObject *Help_HMGetBalloonWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ WindowPtr window;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = HMGetBalloonWindow(&window);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ WinObj_WhichWindow, window);
+ return _res;
+}
+
+static PyMethodDef Help_methods[] = {
+ {"HMGetHelpMenuHandle", (PyCFunction)Help_HMGetHelpMenuHandle, 1,
+ "() -> (MenuHandle mh)"},
+ {"HMRemoveBalloon", (PyCFunction)Help_HMRemoveBalloon, 1,
+ "() -> None"},
+ {"HMIsBalloon", (PyCFunction)Help_HMIsBalloon, 1,
+ "() -> (Boolean _rv)"},
+ {"HMGetBalloons", (PyCFunction)Help_HMGetBalloons, 1,
+ "() -> (Boolean _rv)"},
+ {"HMSetBalloons", (PyCFunction)Help_HMSetBalloons, 1,
+ "(Boolean flag) -> None"},
+ {"HMSetFont", (PyCFunction)Help_HMSetFont, 1,
+ "(SInt16 font) -> None"},
+ {"HMSetFontSize", (PyCFunction)Help_HMSetFontSize, 1,
+ "(UInt16 fontSize) -> None"},
+ {"HMGetFont", (PyCFunction)Help_HMGetFont, 1,
+ "() -> (SInt16 font)"},
+ {"HMGetFontSize", (PyCFunction)Help_HMGetFontSize, 1,
+ "() -> (UInt16 fontSize)"},
+ {"HMSetDialogResID", (PyCFunction)Help_HMSetDialogResID, 1,
+ "(SInt16 resID) -> None"},
+ {"HMSetMenuResID", (PyCFunction)Help_HMSetMenuResID, 1,
+ "(SInt16 menuID, SInt16 resID) -> None"},
+ {"HMScanTemplateItems", (PyCFunction)Help_HMScanTemplateItems, 1,
+ "(SInt16 whichID, SInt16 whichResFile, ResType whichType) -> None"},
+ {"HMGetDialogResID", (PyCFunction)Help_HMGetDialogResID, 1,
+ "() -> (SInt16 resID)"},
+ {"HMGetMenuResID", (PyCFunction)Help_HMGetMenuResID, 1,
+ "(SInt16 menuID) -> (SInt16 resID)"},
+ {"HMGetBalloonWindow", (PyCFunction)Help_HMGetBalloonWindow, 1,
+ "() -> (WindowPtr window)"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_Help(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+ m = Py_InitModule("_Help", Help_methods);
+ d = PyModule_GetDict(m);
+ Help_Error = PyMac_GetOSErrException();
+ if (Help_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Help_Error) != 0)
+ return;
+}
+
+/* ======================== End module _Help ======================== */
+
--- /dev/null
+
+/* ========================== Module _Icn =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Icons.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+
+static PyObject *Icn_Error;
+
+static PyObject *Icn_GetCIcon(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CIconHandle _rv;
+ SInt16 iconID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &iconID))
+ return NULL;
+ _rv = GetCIcon(iconID);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Icn_PlotCIcon(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect theRect;
+ CIconHandle theIcon;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &theRect,
+ ResObj_Convert, &theIcon))
+ return NULL;
+ PlotCIcon(&theRect,
+ theIcon);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_DisposeCIcon(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CIconHandle theIcon;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theIcon))
+ return NULL;
+ DisposeCIcon(theIcon);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_GetIcon(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ SInt16 iconID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &iconID))
+ return NULL;
+ _rv = GetIcon(iconID);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Icn_PlotIcon(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect theRect;
+ Handle theIcon;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &theRect,
+ ResObj_Convert, &theIcon))
+ return NULL;
+ PlotIcon(&theRect,
+ theIcon);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_PlotIconID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Rect theRect;
+ IconAlignmentType align;
+ IconTransformType transform;
+ SInt16 theResID;
+ if (!PyArg_ParseTuple(_args, "O&hhh",
+ PyMac_GetRect, &theRect,
+ &align,
+ &transform,
+ &theResID))
+ return NULL;
+ _err = PlotIconID(&theRect,
+ align,
+ transform,
+ theResID);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_NewIconSuite(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconSuiteRef theIconSuite;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = NewIconSuite(&theIconSuite);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, theIconSuite);
+ return _res;
+}
+
+static PyObject *Icn_AddIconToSuite(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle theIconData;
+ IconSuiteRef theSuite;
+ ResType theType;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ ResObj_Convert, &theIconData,
+ ResObj_Convert, &theSuite,
+ PyMac_GetOSType, &theType))
+ return NULL;
+ _err = AddIconToSuite(theIconData,
+ theSuite,
+ theType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_GetIconFromSuite(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle theIconData;
+ IconSuiteRef theSuite;
+ ResType theType;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &theSuite,
+ PyMac_GetOSType, &theType))
+ return NULL;
+ _err = GetIconFromSuite(&theIconData,
+ theSuite,
+ theType);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, theIconData);
+ return _res;
+}
+
+static PyObject *Icn_GetIconSuite(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconSuiteRef theIconSuite;
+ SInt16 theResID;
+ IconSelectorValue selector;
+ if (!PyArg_ParseTuple(_args, "hl",
+ &theResID,
+ &selector))
+ return NULL;
+ _err = GetIconSuite(&theIconSuite,
+ theResID,
+ selector);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, theIconSuite);
+ return _res;
+}
+
+static PyObject *Icn_DisposeIconSuite(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconSuiteRef theIconSuite;
+ Boolean disposeData;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ ResObj_Convert, &theIconSuite,
+ &disposeData))
+ return NULL;
+ _err = DisposeIconSuite(theIconSuite,
+ disposeData);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_PlotIconSuite(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Rect theRect;
+ IconAlignmentType align;
+ IconTransformType transform;
+ IconSuiteRef theIconSuite;
+ if (!PyArg_ParseTuple(_args, "O&hhO&",
+ PyMac_GetRect, &theRect,
+ &align,
+ &transform,
+ ResObj_Convert, &theIconSuite))
+ return NULL;
+ _err = PlotIconSuite(&theRect,
+ align,
+ transform,
+ theIconSuite);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_LoadIconCache(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Rect theRect;
+ IconAlignmentType align;
+ IconTransformType transform;
+ IconCacheRef theIconCache;
+ if (!PyArg_ParseTuple(_args, "O&hhO&",
+ PyMac_GetRect, &theRect,
+ &align,
+ &transform,
+ ResObj_Convert, &theIconCache))
+ return NULL;
+ _err = LoadIconCache(&theRect,
+ align,
+ transform,
+ theIconCache);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_GetLabel(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 labelNumber;
+ RGBColor labelColor;
+ Str255 labelString;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &labelNumber,
+ PyMac_GetStr255, labelString))
+ return NULL;
+ _err = GetLabel(labelNumber,
+ &labelColor,
+ labelString);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &labelColor);
+ return _res;
+}
+
+static PyObject *Icn_PtInIconID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point testPt;
+ Rect iconRect;
+ IconAlignmentType align;
+ SInt16 iconID;
+ if (!PyArg_ParseTuple(_args, "O&O&hh",
+ PyMac_GetPoint, &testPt,
+ PyMac_GetRect, &iconRect,
+ &align,
+ &iconID))
+ return NULL;
+ _rv = PtInIconID(testPt,
+ &iconRect,
+ align,
+ iconID);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Icn_PtInIconSuite(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point testPt;
+ Rect iconRect;
+ IconAlignmentType align;
+ IconSuiteRef theIconSuite;
+ if (!PyArg_ParseTuple(_args, "O&O&hO&",
+ PyMac_GetPoint, &testPt,
+ PyMac_GetRect, &iconRect,
+ &align,
+ ResObj_Convert, &theIconSuite))
+ return NULL;
+ _rv = PtInIconSuite(testPt,
+ &iconRect,
+ align,
+ theIconSuite);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Icn_RectInIconID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Rect testRect;
+ Rect iconRect;
+ IconAlignmentType align;
+ SInt16 iconID;
+ if (!PyArg_ParseTuple(_args, "O&O&hh",
+ PyMac_GetRect, &testRect,
+ PyMac_GetRect, &iconRect,
+ &align,
+ &iconID))
+ return NULL;
+ _rv = RectInIconID(&testRect,
+ &iconRect,
+ align,
+ iconID);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Icn_RectInIconSuite(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Rect testRect;
+ Rect iconRect;
+ IconAlignmentType align;
+ IconSuiteRef theIconSuite;
+ if (!PyArg_ParseTuple(_args, "O&O&hO&",
+ PyMac_GetRect, &testRect,
+ PyMac_GetRect, &iconRect,
+ &align,
+ ResObj_Convert, &theIconSuite))
+ return NULL;
+ _rv = RectInIconSuite(&testRect,
+ &iconRect,
+ align,
+ theIconSuite);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Icn_IconIDToRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ RgnHandle theRgn;
+ Rect iconRect;
+ IconAlignmentType align;
+ SInt16 iconID;
+ if (!PyArg_ParseTuple(_args, "O&O&hh",
+ ResObj_Convert, &theRgn,
+ PyMac_GetRect, &iconRect,
+ &align,
+ &iconID))
+ return NULL;
+ _err = IconIDToRgn(theRgn,
+ &iconRect,
+ align,
+ iconID);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_IconSuiteToRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ RgnHandle theRgn;
+ Rect iconRect;
+ IconAlignmentType align;
+ IconSuiteRef theIconSuite;
+ if (!PyArg_ParseTuple(_args, "O&O&hO&",
+ ResObj_Convert, &theRgn,
+ PyMac_GetRect, &iconRect,
+ &align,
+ ResObj_Convert, &theIconSuite))
+ return NULL;
+ _err = IconSuiteToRgn(theRgn,
+ &iconRect,
+ align,
+ theIconSuite);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_SetSuiteLabel(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconSuiteRef theSuite;
+ SInt16 theLabel;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ ResObj_Convert, &theSuite,
+ &theLabel))
+ return NULL;
+ _err = SetSuiteLabel(theSuite,
+ theLabel);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_GetSuiteLabel(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ IconSuiteRef theSuite;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theSuite))
+ return NULL;
+ _rv = GetSuiteLabel(theSuite);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Icn_PlotIconHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Rect theRect;
+ IconAlignmentType align;
+ IconTransformType transform;
+ Handle theIcon;
+ if (!PyArg_ParseTuple(_args, "O&hhO&",
+ PyMac_GetRect, &theRect,
+ &align,
+ &transform,
+ ResObj_Convert, &theIcon))
+ return NULL;
+ _err = PlotIconHandle(&theRect,
+ align,
+ transform,
+ theIcon);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_PlotSICNHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Rect theRect;
+ IconAlignmentType align;
+ IconTransformType transform;
+ Handle theSICN;
+ if (!PyArg_ParseTuple(_args, "O&hhO&",
+ PyMac_GetRect, &theRect,
+ &align,
+ &transform,
+ ResObj_Convert, &theSICN))
+ return NULL;
+ _err = PlotSICNHandle(&theRect,
+ align,
+ transform,
+ theSICN);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_PlotCIconHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Rect theRect;
+ IconAlignmentType align;
+ IconTransformType transform;
+ CIconHandle theCIcon;
+ if (!PyArg_ParseTuple(_args, "O&hhO&",
+ PyMac_GetRect, &theRect,
+ &align,
+ &transform,
+ ResObj_Convert, &theCIcon))
+ return NULL;
+ _err = PlotCIconHandle(&theRect,
+ align,
+ transform,
+ theCIcon);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Icn_IconServicesTerminate(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ IconServicesTerminate();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Icn_IconRefToIconFamily(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconRef theIconRef;
+ IconSelectorValue whichIcons;
+ IconFamilyHandle iconFamily;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ ResObj_Convert, &theIconRef,
+ &whichIcons))
+ return NULL;
+ _err = IconRefToIconFamily(theIconRef,
+ whichIcons,
+ &iconFamily);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, iconFamily);
+ return _res;
+}
+
+static PyObject *Icn_IconFamilyToIconSuite(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconFamilyHandle iconFamily;
+ IconSelectorValue whichIcons;
+ IconSuiteRef iconSuite;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ ResObj_Convert, &iconFamily,
+ &whichIcons))
+ return NULL;
+ _err = IconFamilyToIconSuite(iconFamily,
+ whichIcons,
+ &iconSuite);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, iconSuite);
+ return _res;
+}
+
+static PyObject *Icn_IconSuiteToIconFamily(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconSuiteRef iconSuite;
+ IconSelectorValue whichIcons;
+ IconFamilyHandle iconFamily;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ ResObj_Convert, &iconSuite,
+ &whichIcons))
+ return NULL;
+ _err = IconSuiteToIconFamily(iconSuite,
+ whichIcons,
+ &iconFamily);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, iconFamily);
+ return _res;
+}
+
+static PyObject *Icn_SetIconFamilyData(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconFamilyHandle iconFamily;
+ OSType iconType;
+ Handle h;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ ResObj_Convert, &iconFamily,
+ PyMac_GetOSType, &iconType,
+ ResObj_Convert, &h))
+ return NULL;
+ _err = SetIconFamilyData(iconFamily,
+ iconType,
+ h);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_GetIconFamilyData(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconFamilyHandle iconFamily;
+ OSType iconType;
+ Handle h;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ ResObj_Convert, &iconFamily,
+ PyMac_GetOSType, &iconType,
+ ResObj_Convert, &h))
+ return NULL;
+ _err = GetIconFamilyData(iconFamily,
+ iconType,
+ h);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_GetIconRefOwners(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconRef theIconRef;
+ UInt16 owners;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theIconRef))
+ return NULL;
+ _err = GetIconRefOwners(theIconRef,
+ &owners);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("H",
+ owners);
+ return _res;
+}
+
+static PyObject *Icn_AcquireIconRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theIconRef))
+ return NULL;
+ _err = AcquireIconRef(theIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_ReleaseIconRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theIconRef))
+ return NULL;
+ _err = ReleaseIconRef(theIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_GetIconRefFromFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ FSSpec theFile;
+ IconRef theIconRef;
+ SInt16 theLabel;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFSSpec, &theFile))
+ return NULL;
+ _err = GetIconRefFromFile(&theFile,
+ &theIconRef,
+ &theLabel);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&h",
+ ResObj_New, theIconRef,
+ theLabel);
+ return _res;
+}
+
+static PyObject *Icn_GetIconRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 vRefNum;
+ OSType creator;
+ OSType iconType;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "hO&O&",
+ &vRefNum,
+ PyMac_GetOSType, &creator,
+ PyMac_GetOSType, &iconType))
+ return NULL;
+ _err = GetIconRef(vRefNum,
+ creator,
+ iconType,
+ &theIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, theIconRef);
+ return _res;
+}
+
+static PyObject *Icn_GetIconRefFromFolder(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 vRefNum;
+ SInt32 parentFolderID;
+ SInt32 folderID;
+ SInt8 attributes;
+ SInt8 accessPrivileges;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "hllbb",
+ &vRefNum,
+ &parentFolderID,
+ &folderID,
+ &attributes,
+ &accessPrivileges))
+ return NULL;
+ _err = GetIconRefFromFolder(vRefNum,
+ parentFolderID,
+ folderID,
+ attributes,
+ accessPrivileges,
+ &theIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, theIconRef);
+ return _res;
+}
+
+static PyObject *Icn_RegisterIconRefFromIconFamily(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType creator;
+ OSType iconType;
+ IconFamilyHandle iconFamily;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ PyMac_GetOSType, &creator,
+ PyMac_GetOSType, &iconType,
+ ResObj_Convert, &iconFamily))
+ return NULL;
+ _err = RegisterIconRefFromIconFamily(creator,
+ iconType,
+ iconFamily,
+ &theIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, theIconRef);
+ return _res;
+}
+
+static PyObject *Icn_RegisterIconRefFromResource(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType creator;
+ OSType iconType;
+ FSSpec resourceFile;
+ SInt16 resourceID;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "O&O&O&h",
+ PyMac_GetOSType, &creator,
+ PyMac_GetOSType, &iconType,
+ PyMac_GetFSSpec, &resourceFile,
+ &resourceID))
+ return NULL;
+ _err = RegisterIconRefFromResource(creator,
+ iconType,
+ &resourceFile,
+ resourceID,
+ &theIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, theIconRef);
+ return _res;
+}
+
+static PyObject *Icn_UnregisterIconRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType creator;
+ OSType iconType;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &creator,
+ PyMac_GetOSType, &iconType))
+ return NULL;
+ _err = UnregisterIconRef(creator,
+ iconType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_UpdateIconRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theIconRef))
+ return NULL;
+ _err = UpdateIconRef(theIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_OverrideIconRefFromResource(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconRef theIconRef;
+ FSSpec resourceFile;
+ SInt16 resourceID;
+ if (!PyArg_ParseTuple(_args, "O&O&h",
+ ResObj_Convert, &theIconRef,
+ PyMac_GetFSSpec, &resourceFile,
+ &resourceID))
+ return NULL;
+ _err = OverrideIconRefFromResource(theIconRef,
+ &resourceFile,
+ resourceID);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_OverrideIconRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconRef oldIconRef;
+ IconRef newIconRef;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &oldIconRef,
+ ResObj_Convert, &newIconRef))
+ return NULL;
+ _err = OverrideIconRef(oldIconRef,
+ newIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_RemoveIconRefOverride(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theIconRef))
+ return NULL;
+ _err = RemoveIconRefOverride(theIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_CompositeIconRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconRef backgroundIconRef;
+ IconRef foregroundIconRef;
+ IconRef compositeIconRef;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &backgroundIconRef,
+ ResObj_Convert, &foregroundIconRef))
+ return NULL;
+ _err = CompositeIconRef(backgroundIconRef,
+ foregroundIconRef,
+ &compositeIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, compositeIconRef);
+ return _res;
+}
+
+static PyObject *Icn_IsIconRefComposite(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconRef compositeIconRef;
+ IconRef backgroundIconRef;
+ IconRef foregroundIconRef;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &compositeIconRef))
+ return NULL;
+ _err = IsIconRefComposite(compositeIconRef,
+ &backgroundIconRef,
+ &foregroundIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&",
+ ResObj_New, backgroundIconRef,
+ ResObj_New, foregroundIconRef);
+ return _res;
+}
+
+static PyObject *Icn_IsValidIconRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theIconRef))
+ return NULL;
+ _rv = IsValidIconRef(theIconRef);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Icn_PlotIconRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Rect theRect;
+ IconAlignmentType align;
+ IconTransformType transform;
+ IconServicesUsageFlags theIconServicesUsageFlags;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "O&hhlO&",
+ PyMac_GetRect, &theRect,
+ &align,
+ &transform,
+ &theIconServicesUsageFlags,
+ ResObj_Convert, &theIconRef))
+ return NULL;
+ _err = PlotIconRef(&theRect,
+ align,
+ transform,
+ theIconServicesUsageFlags,
+ theIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_PtInIconRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point testPt;
+ Rect iconRect;
+ IconAlignmentType align;
+ IconServicesUsageFlags theIconServicesUsageFlags;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "O&O&hlO&",
+ PyMac_GetPoint, &testPt,
+ PyMac_GetRect, &iconRect,
+ &align,
+ &theIconServicesUsageFlags,
+ ResObj_Convert, &theIconRef))
+ return NULL;
+ _rv = PtInIconRef(&testPt,
+ &iconRect,
+ align,
+ theIconServicesUsageFlags,
+ theIconRef);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Icn_RectInIconRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Rect testRect;
+ Rect iconRect;
+ IconAlignmentType align;
+ IconServicesUsageFlags iconServicesUsageFlags;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "O&O&hlO&",
+ PyMac_GetRect, &testRect,
+ PyMac_GetRect, &iconRect,
+ &align,
+ &iconServicesUsageFlags,
+ ResObj_Convert, &theIconRef))
+ return NULL;
+ _rv = RectInIconRef(&testRect,
+ &iconRect,
+ align,
+ iconServicesUsageFlags,
+ theIconRef);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Icn_IconRefToRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ RgnHandle theRgn;
+ Rect iconRect;
+ IconAlignmentType align;
+ IconServicesUsageFlags iconServicesUsageFlags;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "O&O&hlO&",
+ ResObj_Convert, &theRgn,
+ PyMac_GetRect, &iconRect,
+ &align,
+ &iconServicesUsageFlags,
+ ResObj_Convert, &theIconRef))
+ return NULL;
+ _err = IconRefToRgn(theRgn,
+ &iconRect,
+ align,
+ iconServicesUsageFlags,
+ theIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_GetIconSizesFromIconRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconSelectorValue iconSelectorInput;
+ IconSelectorValue iconSelectorOutputPtr;
+ IconServicesUsageFlags iconServicesUsageFlags;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "llO&",
+ &iconSelectorInput,
+ &iconServicesUsageFlags,
+ ResObj_Convert, &theIconRef))
+ return NULL;
+ _err = GetIconSizesFromIconRef(iconSelectorInput,
+ &iconSelectorOutputPtr,
+ iconServicesUsageFlags,
+ theIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ iconSelectorOutputPtr);
+ return _res;
+}
+
+static PyObject *Icn_FlushIconRefs(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType creator;
+ OSType iconType;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &creator,
+ PyMac_GetOSType, &iconType))
+ return NULL;
+ _err = FlushIconRefs(creator,
+ iconType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_FlushIconRefsByVolume(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 vRefNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &vRefNum))
+ return NULL;
+ _err = FlushIconRefsByVolume(vRefNum);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_SetCustomIconsEnabled(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 vRefNum;
+ Boolean enableCustomIcons;
+ if (!PyArg_ParseTuple(_args, "hb",
+ &vRefNum,
+ &enableCustomIcons))
+ return NULL;
+ _err = SetCustomIconsEnabled(vRefNum,
+ enableCustomIcons);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Icn_GetCustomIconsEnabled(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 vRefNum;
+ Boolean customIconsEnabled;
+ if (!PyArg_ParseTuple(_args, "h",
+ &vRefNum))
+ return NULL;
+ _err = GetCustomIconsEnabled(vRefNum,
+ &customIconsEnabled);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("b",
+ customIconsEnabled);
+ return _res;
+}
+
+static PyObject *Icn_IsIconRefMaskEmpty(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ IconRef iconRef;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &iconRef))
+ return NULL;
+ _rv = IsIconRefMaskEmpty(iconRef);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Icn_GetIconRefVariant(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ IconRef _rv;
+ IconRef inIconRef;
+ OSType inVariant;
+ IconTransformType outTransform;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &inIconRef,
+ PyMac_GetOSType, &inVariant))
+ return NULL;
+ _rv = GetIconRefVariant(inIconRef,
+ inVariant,
+ &outTransform);
+ _res = Py_BuildValue("O&h",
+ ResObj_New, _rv,
+ outTransform);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Icn_RegisterIconRefFromIconFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType creator;
+ OSType iconType;
+ FSSpec iconFile;
+ IconRef theIconRef;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ PyMac_GetOSType, &creator,
+ PyMac_GetOSType, &iconType,
+ PyMac_GetFSSpec, &iconFile))
+ return NULL;
+ _err = RegisterIconRefFromIconFile(creator,
+ iconType,
+ &iconFile,
+ &theIconRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, theIconRef);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Icn_ReadIconFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ FSSpec iconFile;
+ IconFamilyHandle iconFamily;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFSSpec, &iconFile))
+ return NULL;
+ _err = ReadIconFile(&iconFile,
+ &iconFamily);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, iconFamily);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Icn_WriteIconFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ IconFamilyHandle iconFamily;
+ FSSpec iconFile;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &iconFamily,
+ PyMac_GetFSSpec, &iconFile))
+ return NULL;
+ _err = WriteIconFile(iconFamily,
+ &iconFile);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyMethodDef Icn_methods[] = {
+ {"GetCIcon", (PyCFunction)Icn_GetCIcon, 1,
+ "(SInt16 iconID) -> (CIconHandle _rv)"},
+ {"PlotCIcon", (PyCFunction)Icn_PlotCIcon, 1,
+ "(Rect theRect, CIconHandle theIcon) -> None"},
+ {"DisposeCIcon", (PyCFunction)Icn_DisposeCIcon, 1,
+ "(CIconHandle theIcon) -> None"},
+ {"GetIcon", (PyCFunction)Icn_GetIcon, 1,
+ "(SInt16 iconID) -> (Handle _rv)"},
+ {"PlotIcon", (PyCFunction)Icn_PlotIcon, 1,
+ "(Rect theRect, Handle theIcon) -> None"},
+ {"PlotIconID", (PyCFunction)Icn_PlotIconID, 1,
+ "(Rect theRect, IconAlignmentType align, IconTransformType transform, SInt16 theResID) -> None"},
+ {"NewIconSuite", (PyCFunction)Icn_NewIconSuite, 1,
+ "() -> (IconSuiteRef theIconSuite)"},
+ {"AddIconToSuite", (PyCFunction)Icn_AddIconToSuite, 1,
+ "(Handle theIconData, IconSuiteRef theSuite, ResType theType) -> None"},
+ {"GetIconFromSuite", (PyCFunction)Icn_GetIconFromSuite, 1,
+ "(IconSuiteRef theSuite, ResType theType) -> (Handle theIconData)"},
+ {"GetIconSuite", (PyCFunction)Icn_GetIconSuite, 1,
+ "(SInt16 theResID, IconSelectorValue selector) -> (IconSuiteRef theIconSuite)"},
+ {"DisposeIconSuite", (PyCFunction)Icn_DisposeIconSuite, 1,
+ "(IconSuiteRef theIconSuite, Boolean disposeData) -> None"},
+ {"PlotIconSuite", (PyCFunction)Icn_PlotIconSuite, 1,
+ "(Rect theRect, IconAlignmentType align, IconTransformType transform, IconSuiteRef theIconSuite) -> None"},
+ {"LoadIconCache", (PyCFunction)Icn_LoadIconCache, 1,
+ "(Rect theRect, IconAlignmentType align, IconTransformType transform, IconCacheRef theIconCache) -> None"},
+ {"GetLabel", (PyCFunction)Icn_GetLabel, 1,
+ "(SInt16 labelNumber, Str255 labelString) -> (RGBColor labelColor)"},
+ {"PtInIconID", (PyCFunction)Icn_PtInIconID, 1,
+ "(Point testPt, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)"},
+ {"PtInIconSuite", (PyCFunction)Icn_PtInIconSuite, 1,
+ "(Point testPt, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)"},
+ {"RectInIconID", (PyCFunction)Icn_RectInIconID, 1,
+ "(Rect testRect, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)"},
+ {"RectInIconSuite", (PyCFunction)Icn_RectInIconSuite, 1,
+ "(Rect testRect, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)"},
+ {"IconIDToRgn", (PyCFunction)Icn_IconIDToRgn, 1,
+ "(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> None"},
+ {"IconSuiteToRgn", (PyCFunction)Icn_IconSuiteToRgn, 1,
+ "(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> None"},
+ {"SetSuiteLabel", (PyCFunction)Icn_SetSuiteLabel, 1,
+ "(IconSuiteRef theSuite, SInt16 theLabel) -> None"},
+ {"GetSuiteLabel", (PyCFunction)Icn_GetSuiteLabel, 1,
+ "(IconSuiteRef theSuite) -> (SInt16 _rv)"},
+ {"PlotIconHandle", (PyCFunction)Icn_PlotIconHandle, 1,
+ "(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theIcon) -> None"},
+ {"PlotSICNHandle", (PyCFunction)Icn_PlotSICNHandle, 1,
+ "(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theSICN) -> None"},
+ {"PlotCIconHandle", (PyCFunction)Icn_PlotCIconHandle, 1,
+ "(Rect theRect, IconAlignmentType align, IconTransformType transform, CIconHandle theCIcon) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+ {"IconServicesTerminate", (PyCFunction)Icn_IconServicesTerminate, 1,
+ "() -> None"},
+#endif
+ {"IconRefToIconFamily", (PyCFunction)Icn_IconRefToIconFamily, 1,
+ "(IconRef theIconRef, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)"},
+ {"IconFamilyToIconSuite", (PyCFunction)Icn_IconFamilyToIconSuite, 1,
+ "(IconFamilyHandle iconFamily, IconSelectorValue whichIcons) -> (IconSuiteRef iconSuite)"},
+ {"IconSuiteToIconFamily", (PyCFunction)Icn_IconSuiteToIconFamily, 1,
+ "(IconSuiteRef iconSuite, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)"},
+ {"SetIconFamilyData", (PyCFunction)Icn_SetIconFamilyData, 1,
+ "(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None"},
+ {"GetIconFamilyData", (PyCFunction)Icn_GetIconFamilyData, 1,
+ "(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None"},
+ {"GetIconRefOwners", (PyCFunction)Icn_GetIconRefOwners, 1,
+ "(IconRef theIconRef) -> (UInt16 owners)"},
+ {"AcquireIconRef", (PyCFunction)Icn_AcquireIconRef, 1,
+ "(IconRef theIconRef) -> None"},
+ {"ReleaseIconRef", (PyCFunction)Icn_ReleaseIconRef, 1,
+ "(IconRef theIconRef) -> None"},
+ {"GetIconRefFromFile", (PyCFunction)Icn_GetIconRefFromFile, 1,
+ "(FSSpec theFile) -> (IconRef theIconRef, SInt16 theLabel)"},
+ {"GetIconRef", (PyCFunction)Icn_GetIconRef, 1,
+ "(SInt16 vRefNum, OSType creator, OSType iconType) -> (IconRef theIconRef)"},
+ {"GetIconRefFromFolder", (PyCFunction)Icn_GetIconRefFromFolder, 1,
+ "(SInt16 vRefNum, SInt32 parentFolderID, SInt32 folderID, SInt8 attributes, SInt8 accessPrivileges) -> (IconRef theIconRef)"},
+ {"RegisterIconRefFromIconFamily", (PyCFunction)Icn_RegisterIconRefFromIconFamily, 1,
+ "(OSType creator, OSType iconType, IconFamilyHandle iconFamily) -> (IconRef theIconRef)"},
+ {"RegisterIconRefFromResource", (PyCFunction)Icn_RegisterIconRefFromResource, 1,
+ "(OSType creator, OSType iconType, FSSpec resourceFile, SInt16 resourceID) -> (IconRef theIconRef)"},
+ {"UnregisterIconRef", (PyCFunction)Icn_UnregisterIconRef, 1,
+ "(OSType creator, OSType iconType) -> None"},
+ {"UpdateIconRef", (PyCFunction)Icn_UpdateIconRef, 1,
+ "(IconRef theIconRef) -> None"},
+ {"OverrideIconRefFromResource", (PyCFunction)Icn_OverrideIconRefFromResource, 1,
+ "(IconRef theIconRef, FSSpec resourceFile, SInt16 resourceID) -> None"},
+ {"OverrideIconRef", (PyCFunction)Icn_OverrideIconRef, 1,
+ "(IconRef oldIconRef, IconRef newIconRef) -> None"},
+ {"RemoveIconRefOverride", (PyCFunction)Icn_RemoveIconRefOverride, 1,
+ "(IconRef theIconRef) -> None"},
+ {"CompositeIconRef", (PyCFunction)Icn_CompositeIconRef, 1,
+ "(IconRef backgroundIconRef, IconRef foregroundIconRef) -> (IconRef compositeIconRef)"},
+ {"IsIconRefComposite", (PyCFunction)Icn_IsIconRefComposite, 1,
+ "(IconRef compositeIconRef) -> (IconRef backgroundIconRef, IconRef foregroundIconRef)"},
+ {"IsValidIconRef", (PyCFunction)Icn_IsValidIconRef, 1,
+ "(IconRef theIconRef) -> (Boolean _rv)"},
+ {"PlotIconRef", (PyCFunction)Icn_PlotIconRef, 1,
+ "(Rect theRect, IconAlignmentType align, IconTransformType transform, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> None"},
+ {"PtInIconRef", (PyCFunction)Icn_PtInIconRef, 1,
+ "(Point testPt, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)"},
+ {"RectInIconRef", (PyCFunction)Icn_RectInIconRef, 1,
+ "(Rect testRect, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)"},
+ {"IconRefToRgn", (PyCFunction)Icn_IconRefToRgn, 1,
+ "(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> None"},
+ {"GetIconSizesFromIconRef", (PyCFunction)Icn_GetIconSizesFromIconRef, 1,
+ "(IconSelectorValue iconSelectorInput, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (IconSelectorValue iconSelectorOutputPtr)"},
+ {"FlushIconRefs", (PyCFunction)Icn_FlushIconRefs, 1,
+ "(OSType creator, OSType iconType) -> None"},
+ {"FlushIconRefsByVolume", (PyCFunction)Icn_FlushIconRefsByVolume, 1,
+ "(SInt16 vRefNum) -> None"},
+ {"SetCustomIconsEnabled", (PyCFunction)Icn_SetCustomIconsEnabled, 1,
+ "(SInt16 vRefNum, Boolean enableCustomIcons) -> None"},
+ {"GetCustomIconsEnabled", (PyCFunction)Icn_GetCustomIconsEnabled, 1,
+ "(SInt16 vRefNum) -> (Boolean customIconsEnabled)"},
+ {"IsIconRefMaskEmpty", (PyCFunction)Icn_IsIconRefMaskEmpty, 1,
+ "(IconRef iconRef) -> (Boolean _rv)"},
+
+#if TARGET_API_MAC_CARBON
+ {"GetIconRefVariant", (PyCFunction)Icn_GetIconRefVariant, 1,
+ "(IconRef inIconRef, OSType inVariant) -> (IconRef _rv, IconTransformType outTransform)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"RegisterIconRefFromIconFile", (PyCFunction)Icn_RegisterIconRefFromIconFile, 1,
+ "(OSType creator, OSType iconType, FSSpec iconFile) -> (IconRef theIconRef)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"ReadIconFile", (PyCFunction)Icn_ReadIconFile, 1,
+ "(FSSpec iconFile) -> (IconFamilyHandle iconFamily)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"WriteIconFile", (PyCFunction)Icn_WriteIconFile, 1,
+ "(IconFamilyHandle iconFamily, FSSpec iconFile) -> None"},
+#endif
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_Icn(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+ m = Py_InitModule("_Icn", Icn_methods);
+ d = PyModule_GetDict(m);
+ Icn_Error = PyMac_GetOSErrException();
+ if (Icn_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Icn_Error) != 0)
+ return;
+}
+
+/* ======================== End module _Icn ========================= */
+
--- /dev/null
+
+/* ========================== Module _List ========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Lists.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+extern PyObject *_ListObj_New(ListHandle);
+extern int _ListObj_Convert(PyObject *, ListHandle *);
+
+#define ListObj_New _ListObj_New
+#define ListObj_Convert _ListObj_Convert
+#endif
+
+#if !ACCESSOR_CALLS_ARE_FUNCTIONS
+#define GetListPort(list) ((CGrafPtr)(*(list))->port)
+#define GetListVerticalScrollBar(list) ((*(list))->vScroll)
+#define GetListHorizontalScrollBar(list) ((*(list))->hScroll)
+#define GetListActive(list) ((*(list))->lActive)
+#define GetListClickTime(list) ((*(list))->clikTime)
+#define GetListRefCon(list) ((*(list))->refCon)
+#define GetListDefinition(list) ((*(list))->listDefProc) /* XXX Is this indeed the same? */
+#define GetListUserHandle(list) ((*(list))->userHandle)
+#define GetListDataHandle(list) ((*(list))->cells)
+#define GetListFlags(list) ((*(list))->listFlags)
+#define GetListSelectionFlags(list) ((*(list))->selFlags)
+#define SetListViewBounds(list, bounds) (((*(list))->rView) = *(bounds))
+
+#define SetListPort(list, port) (((*(list))->port) = (GrafPtr)(port))
+#define SetListCellIndent(list, ind) (((*(list))->indent) = *(ind))
+#define SetListClickTime(list, time) (((*(list))->clikTime) = (time))
+#define SetListLastClick(list, click) (((*(list)->lastClick) = *(click))
+#define SetListRefCon(list, refcon) (((*(list))->refCon) = (refcon))
+#define SetListUserHandle(list, handle) (((*(list))->userHandle) = (handle))
+#define SetListFlags(list, flags) (((*(list))->listFlags) = (flags))
+#define SetListSelectionFlags(list, flags) (((*(list))->selFlags) = (flags))
+
+#endif
+
+#define as_List(x) ((ListHandle)x)
+#define as_Resource(lh) ((Handle)lh)
+
+static PyObject *List_Error;
+
+/* ------------------------ Object type List ------------------------ */
+
+PyTypeObject List_Type;
+
+#define ListObj_Check(x) ((x)->ob_type == &List_Type)
+
+typedef struct ListObject {
+ PyObject_HEAD
+ ListHandle ob_itself;
+ int ob_must_be_disposed;
+} ListObject;
+
+PyObject *ListObj_New(ListHandle itself)
+{
+ ListObject *it;
+ if (itself == NULL) {
+ PyErr_SetString(List_Error,"Cannot create null List");
+ return NULL;
+ }
+ it = PyObject_NEW(ListObject, &List_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_must_be_disposed = 1;
+ return (PyObject *)it;
+}
+ListObj_Convert(PyObject *v, ListHandle *p_itself)
+{
+ if (!ListObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "List required");
+ return 0;
+ }
+ *p_itself = ((ListObject *)v)->ob_itself;
+ return 1;
+}
+
+static void ListObj_dealloc(ListObject *self)
+{
+ if (self->ob_must_be_disposed && self->ob_itself) LDispose(self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *ListObj_LAddColumn(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ short count;
+ short colNum;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &count,
+ &colNum))
+ return NULL;
+ _rv = LAddColumn(count,
+ colNum,
+ _self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *ListObj_LAddRow(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ short count;
+ short rowNum;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &count,
+ &rowNum))
+ return NULL;
+ _rv = LAddRow(count,
+ rowNum,
+ _self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *ListObj_LDelColumn(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short count;
+ short colNum;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &count,
+ &colNum))
+ return NULL;
+ LDelColumn(count,
+ colNum,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ListObj_LDelRow(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short count;
+ short rowNum;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &count,
+ &rowNum))
+ return NULL;
+ LDelRow(count,
+ rowNum,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ListObj_LGetSelect(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Boolean next;
+ Point theCell;
+ if (!PyArg_ParseTuple(_args, "bO&",
+ &next,
+ PyMac_GetPoint, &theCell))
+ return NULL;
+ _rv = LGetSelect(next,
+ &theCell,
+ _self->ob_itself);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildPoint, theCell);
+ return _res;
+}
+
+static PyObject *ListObj_LLastClick(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LLastClick(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, _rv);
+ return _res;
+}
+
+static PyObject *ListObj_LNextCell(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Boolean hNext;
+ Boolean vNext;
+ Point theCell;
+ if (!PyArg_ParseTuple(_args, "bbO&",
+ &hNext,
+ &vNext,
+ PyMac_GetPoint, &theCell))
+ return NULL;
+ _rv = LNextCell(hNext,
+ vNext,
+ &theCell,
+ _self->ob_itself);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildPoint, theCell);
+ return _res;
+}
+
+static PyObject *ListObj_LSize(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short listWidth;
+ short listHeight;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &listWidth,
+ &listHeight))
+ return NULL;
+ LSize(listWidth,
+ listHeight,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ListObj_LSetDrawingMode(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean drawIt;
+ if (!PyArg_ParseTuple(_args, "b",
+ &drawIt))
+ return NULL;
+ LSetDrawingMode(drawIt,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ListObj_LScroll(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short dCols;
+ short dRows;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &dCols,
+ &dRows))
+ return NULL;
+ LScroll(dCols,
+ dRows,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ListObj_LAutoScroll(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ LAutoScroll(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ListObj_LUpdate(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle theRgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theRgn))
+ return NULL;
+ LUpdate(theRgn,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ListObj_LActivate(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean act;
+ if (!PyArg_ParseTuple(_args, "b",
+ &act))
+ return NULL;
+ LActivate(act,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ListObj_LCellSize(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point cSize;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &cSize))
+ return NULL;
+ LCellSize(cSize,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ListObj_LClick(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point pt;
+ short modifiers;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetPoint, &pt,
+ &modifiers))
+ return NULL;
+ _rv = LClick(pt,
+ modifiers,
+ _self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *ListObj_LAddToCell(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ char *dataPtr__in__;
+ short dataPtr__len__;
+ int dataPtr__in_len__;
+ Point theCell;
+ if (!PyArg_ParseTuple(_args, "s#O&",
+ &dataPtr__in__, &dataPtr__in_len__,
+ PyMac_GetPoint, &theCell))
+ return NULL;
+ dataPtr__len__ = dataPtr__in_len__;
+ LAddToCell(dataPtr__in__, dataPtr__len__,
+ theCell,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *ListObj_LClrCell(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point theCell;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &theCell))
+ return NULL;
+ LClrCell(theCell,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ListObj_LGetCell(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ char *dataPtr__out__;
+ short dataPtr__len__;
+ int dataPtr__in_len__;
+ Point theCell;
+ if (!PyArg_ParseTuple(_args, "iO&",
+ &dataPtr__in_len__,
+ PyMac_GetPoint, &theCell))
+ return NULL;
+ if ((dataPtr__out__ = malloc(dataPtr__in_len__)) == NULL)
+ {
+ PyErr_NoMemory();
+ goto dataPtr__error__;
+ }
+ dataPtr__len__ = dataPtr__in_len__;
+ LGetCell(dataPtr__out__, &dataPtr__len__,
+ theCell,
+ _self->ob_itself);
+ _res = Py_BuildValue("s#",
+ dataPtr__out__, (int)dataPtr__len__);
+ free(dataPtr__out__);
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *ListObj_LRect(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect cellRect;
+ Point theCell;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &theCell))
+ return NULL;
+ LRect(&cellRect,
+ theCell,
+ _self->ob_itself);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &cellRect);
+ return _res;
+}
+
+static PyObject *ListObj_LSetCell(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ char *dataPtr__in__;
+ short dataPtr__len__;
+ int dataPtr__in_len__;
+ Point theCell;
+ if (!PyArg_ParseTuple(_args, "s#O&",
+ &dataPtr__in__, &dataPtr__in_len__,
+ PyMac_GetPoint, &theCell))
+ return NULL;
+ dataPtr__len__ = dataPtr__in_len__;
+ LSetCell(dataPtr__in__, dataPtr__len__,
+ theCell,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *ListObj_LSetSelect(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean setIt;
+ Point theCell;
+ if (!PyArg_ParseTuple(_args, "bO&",
+ &setIt,
+ PyMac_GetPoint, &theCell))
+ return NULL;
+ LSetSelect(setIt,
+ theCell,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ListObj_LDraw(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point theCell;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &theCell))
+ return NULL;
+ LDraw(theCell,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ListObj_as_Resource(ListObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = as_Resource(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyMethodDef ListObj_methods[] = {
+ {"LAddColumn", (PyCFunction)ListObj_LAddColumn, 1,
+ "(short count, short colNum) -> (short _rv)"},
+ {"LAddRow", (PyCFunction)ListObj_LAddRow, 1,
+ "(short count, short rowNum) -> (short _rv)"},
+ {"LDelColumn", (PyCFunction)ListObj_LDelColumn, 1,
+ "(short count, short colNum) -> None"},
+ {"LDelRow", (PyCFunction)ListObj_LDelRow, 1,
+ "(short count, short rowNum) -> None"},
+ {"LGetSelect", (PyCFunction)ListObj_LGetSelect, 1,
+ "(Boolean next, Point theCell) -> (Boolean _rv, Point theCell)"},
+ {"LLastClick", (PyCFunction)ListObj_LLastClick, 1,
+ "() -> (Point _rv)"},
+ {"LNextCell", (PyCFunction)ListObj_LNextCell, 1,
+ "(Boolean hNext, Boolean vNext, Point theCell) -> (Boolean _rv, Point theCell)"},
+ {"LSize", (PyCFunction)ListObj_LSize, 1,
+ "(short listWidth, short listHeight) -> None"},
+ {"LSetDrawingMode", (PyCFunction)ListObj_LSetDrawingMode, 1,
+ "(Boolean drawIt) -> None"},
+ {"LScroll", (PyCFunction)ListObj_LScroll, 1,
+ "(short dCols, short dRows) -> None"},
+ {"LAutoScroll", (PyCFunction)ListObj_LAutoScroll, 1,
+ "() -> None"},
+ {"LUpdate", (PyCFunction)ListObj_LUpdate, 1,
+ "(RgnHandle theRgn) -> None"},
+ {"LActivate", (PyCFunction)ListObj_LActivate, 1,
+ "(Boolean act) -> None"},
+ {"LCellSize", (PyCFunction)ListObj_LCellSize, 1,
+ "(Point cSize) -> None"},
+ {"LClick", (PyCFunction)ListObj_LClick, 1,
+ "(Point pt, short modifiers) -> (Boolean _rv)"},
+ {"LAddToCell", (PyCFunction)ListObj_LAddToCell, 1,
+ "(Buffer dataPtr, Point theCell) -> None"},
+ {"LClrCell", (PyCFunction)ListObj_LClrCell, 1,
+ "(Point theCell) -> None"},
+ {"LGetCell", (PyCFunction)ListObj_LGetCell, 1,
+ "(Buffer dataPtr, Point theCell) -> (Buffer dataPtr)"},
+ {"LRect", (PyCFunction)ListObj_LRect, 1,
+ "(Point theCell) -> (Rect cellRect)"},
+ {"LSetCell", (PyCFunction)ListObj_LSetCell, 1,
+ "(Buffer dataPtr, Point theCell) -> None"},
+ {"LSetSelect", (PyCFunction)ListObj_LSetSelect, 1,
+ "(Boolean setIt, Point theCell) -> None"},
+ {"LDraw", (PyCFunction)ListObj_LDraw, 1,
+ "(Point theCell) -> None"},
+ {"as_Resource", (PyCFunction)ListObj_as_Resource, 1,
+ "() -> (Handle _rv)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain ListObj_chain = { ListObj_methods, NULL };
+
+static PyObject *ListObj_getattr(ListObject *self, char *name)
+{
+ {
+ /* XXXX Should we HLock() here?? */
+ if ( strcmp(name, "listFlags") == 0 )
+ return Py_BuildValue("l", (long)(*self->ob_itself)->listFlags & 0xff);
+ if ( strcmp(name, "selFlags") == 0 )
+ return Py_BuildValue("l", (long)(*self->ob_itself)->selFlags & 0xff);
+ }
+ return Py_FindMethodInChain(&ListObj_chain, (PyObject *)self, name);
+}
+
+static int
+ListObj_setattr(ListObject *self, char *name, PyObject *value)
+{
+ long intval;
+
+ if ( value == NULL || !PyInt_Check(value) )
+ return -1;
+ intval = PyInt_AsLong(value);
+ if (strcmp(name, "listFlags") == 0 ) {
+ /* XXXX Should we HLock the handle here?? */
+ (*self->ob_itself)->listFlags = intval;
+ return 0;
+ }
+ if (strcmp(name, "selFlags") == 0 ) {
+ (*self->ob_itself)->selFlags = intval;
+ return 0;
+ }
+ return -1;
+}
+
+
+#define ListObj_compare NULL
+
+#define ListObj_repr NULL
+
+#define ListObj_hash NULL
+
+PyTypeObject List_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "List", /*tp_name*/
+ sizeof(ListObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) ListObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) ListObj_getattr, /*tp_getattr*/
+ (setattrfunc) ListObj_setattr, /*tp_setattr*/
+ (cmpfunc) ListObj_compare, /*tp_compare*/
+ (reprfunc) ListObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) ListObj_hash, /*tp_hash*/
+};
+
+/* ---------------------- End object type List ---------------------- */
+
+
+static PyObject *List_LNew(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ListHandle _rv;
+ Rect rView;
+ Rect dataBounds;
+ Point cSize;
+ short theProc;
+ WindowPtr theWindow;
+ Boolean drawIt;
+ Boolean hasGrow;
+ Boolean scrollHoriz;
+ Boolean scrollVert;
+ if (!PyArg_ParseTuple(_args, "O&O&O&hO&bbbb",
+ PyMac_GetRect, &rView,
+ PyMac_GetRect, &dataBounds,
+ PyMac_GetPoint, &cSize,
+ &theProc,
+ WinObj_Convert, &theWindow,
+ &drawIt,
+ &hasGrow,
+ &scrollHoriz,
+ &scrollVert))
+ return NULL;
+ _rv = LNew(&rView,
+ &dataBounds,
+ cSize,
+ theProc,
+ theWindow,
+ drawIt,
+ hasGrow,
+ scrollHoriz,
+ scrollVert);
+ _res = Py_BuildValue("O&",
+ ListObj_New, _rv);
+ return _res;
+}
+
+static PyObject *List_GetListPort(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr _rv;
+ ListHandle list;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ListObj_Convert, &list))
+ return NULL;
+ _rv = GetListPort(list);
+ _res = Py_BuildValue("O&",
+ GrafObj_New, _rv);
+ return _res;
+}
+
+static PyObject *List_GetListVerticalScrollBar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ControlHandle _rv;
+ ListHandle list;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ListObj_Convert, &list))
+ return NULL;
+ _rv = GetListVerticalScrollBar(list);
+ _res = Py_BuildValue("O&",
+ CtlObj_New, _rv);
+ return _res;
+}
+
+static PyObject *List_GetListHorizontalScrollBar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ControlHandle _rv;
+ ListHandle list;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ListObj_Convert, &list))
+ return NULL;
+ _rv = GetListHorizontalScrollBar(list);
+ _res = Py_BuildValue("O&",
+ CtlObj_New, _rv);
+ return _res;
+}
+
+static PyObject *List_GetListActive(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ ListHandle list;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ListObj_Convert, &list))
+ return NULL;
+ _rv = GetListActive(list);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *List_GetListClickTime(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 _rv;
+ ListHandle list;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ListObj_Convert, &list))
+ return NULL;
+ _rv = GetListClickTime(list);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *List_GetListRefCon(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 _rv;
+ ListHandle list;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ListObj_Convert, &list))
+ return NULL;
+ _rv = GetListRefCon(list);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *List_GetListDefinition(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ListHandle list;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ListObj_Convert, &list))
+ return NULL;
+ _rv = GetListDefinition(list);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *List_GetListUserHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ListHandle list;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ListObj_Convert, &list))
+ return NULL;
+ _rv = GetListUserHandle(list);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *List_GetListDataHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DataHandle _rv;
+ ListHandle list;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ListObj_Convert, &list))
+ return NULL;
+ _rv = GetListDataHandle(list);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *List_GetListFlags(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OptionBits _rv;
+ ListHandle list;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ListObj_Convert, &list))
+ return NULL;
+ _rv = GetListFlags(list);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *List_GetListSelectionFlags(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OptionBits _rv;
+ ListHandle list;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ListObj_Convert, &list))
+ return NULL;
+ _rv = GetListSelectionFlags(list);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *List_SetListViewBounds(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ListHandle list;
+ Rect view;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ListObj_Convert, &list,
+ PyMac_GetRect, &view))
+ return NULL;
+ SetListViewBounds(list,
+ &view);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *List_SetListPort(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ListHandle list;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ListObj_Convert, &list,
+ GrafObj_Convert, &port))
+ return NULL;
+ SetListPort(list,
+ port);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *List_SetListCellIndent(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ListHandle list;
+ Point indent;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ListObj_Convert, &list,
+ PyMac_GetPoint, &indent))
+ return NULL;
+ SetListCellIndent(list,
+ &indent);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *List_SetListClickTime(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ListHandle list;
+ SInt32 time;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ ListObj_Convert, &list,
+ &time))
+ return NULL;
+ SetListClickTime(list,
+ time);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *List_SetListRefCon(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ListHandle list;
+ SInt32 refCon;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ ListObj_Convert, &list,
+ &refCon))
+ return NULL;
+ SetListRefCon(list,
+ refCon);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *List_SetListUserHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ListHandle list;
+ Handle userHandle;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ListObj_Convert, &list,
+ ResObj_Convert, &userHandle))
+ return NULL;
+ SetListUserHandle(list,
+ userHandle);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *List_SetListFlags(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ListHandle list;
+ OptionBits listFlags;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ ListObj_Convert, &list,
+ &listFlags))
+ return NULL;
+ SetListFlags(list,
+ listFlags);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *List_SetListSelectionFlags(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ListHandle list;
+ OptionBits selectionFlags;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ ListObj_Convert, &list,
+ &selectionFlags))
+ return NULL;
+ SetListSelectionFlags(list,
+ selectionFlags);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *List_as_List(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ Handle h;
+ ListObject *l;
+ if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &h))
+ return NULL;
+ l = (ListObject *)ListObj_New(as_List(h));
+ l->ob_must_be_disposed = 0;
+ return Py_BuildValue("O", l);
+
+}
+
+static PyMethodDef List_methods[] = {
+ {"LNew", (PyCFunction)List_LNew, 1,
+ "(Rect rView, Rect dataBounds, Point cSize, short theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle _rv)"},
+ {"GetListPort", (PyCFunction)List_GetListPort, 1,
+ "(ListHandle list) -> (CGrafPtr _rv)"},
+ {"GetListVerticalScrollBar", (PyCFunction)List_GetListVerticalScrollBar, 1,
+ "(ListHandle list) -> (ControlHandle _rv)"},
+ {"GetListHorizontalScrollBar", (PyCFunction)List_GetListHorizontalScrollBar, 1,
+ "(ListHandle list) -> (ControlHandle _rv)"},
+ {"GetListActive", (PyCFunction)List_GetListActive, 1,
+ "(ListHandle list) -> (Boolean _rv)"},
+ {"GetListClickTime", (PyCFunction)List_GetListClickTime, 1,
+ "(ListHandle list) -> (SInt32 _rv)"},
+ {"GetListRefCon", (PyCFunction)List_GetListRefCon, 1,
+ "(ListHandle list) -> (SInt32 _rv)"},
+ {"GetListDefinition", (PyCFunction)List_GetListDefinition, 1,
+ "(ListHandle list) -> (Handle _rv)"},
+ {"GetListUserHandle", (PyCFunction)List_GetListUserHandle, 1,
+ "(ListHandle list) -> (Handle _rv)"},
+ {"GetListDataHandle", (PyCFunction)List_GetListDataHandle, 1,
+ "(ListHandle list) -> (DataHandle _rv)"},
+ {"GetListFlags", (PyCFunction)List_GetListFlags, 1,
+ "(ListHandle list) -> (OptionBits _rv)"},
+ {"GetListSelectionFlags", (PyCFunction)List_GetListSelectionFlags, 1,
+ "(ListHandle list) -> (OptionBits _rv)"},
+ {"SetListViewBounds", (PyCFunction)List_SetListViewBounds, 1,
+ "(ListHandle list, Rect view) -> None"},
+ {"SetListPort", (PyCFunction)List_SetListPort, 1,
+ "(ListHandle list, CGrafPtr port) -> None"},
+ {"SetListCellIndent", (PyCFunction)List_SetListCellIndent, 1,
+ "(ListHandle list, Point indent) -> None"},
+ {"SetListClickTime", (PyCFunction)List_SetListClickTime, 1,
+ "(ListHandle list, SInt32 time) -> None"},
+ {"SetListRefCon", (PyCFunction)List_SetListRefCon, 1,
+ "(ListHandle list, SInt32 refCon) -> None"},
+ {"SetListUserHandle", (PyCFunction)List_SetListUserHandle, 1,
+ "(ListHandle list, Handle userHandle) -> None"},
+ {"SetListFlags", (PyCFunction)List_SetListFlags, 1,
+ "(ListHandle list, OptionBits listFlags) -> None"},
+ {"SetListSelectionFlags", (PyCFunction)List_SetListSelectionFlags, 1,
+ "(ListHandle list, OptionBits selectionFlags) -> None"},
+ {"as_List", (PyCFunction)List_as_List, 1,
+ "(Resource)->List.\nReturns List object (which is not auto-freed!)"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_List(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(ListHandle, ListObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(ListHandle, ListObj_Convert);
+
+
+ m = Py_InitModule("_List", List_methods);
+ d = PyModule_GetDict(m);
+ List_Error = PyMac_GetOSErrException();
+ if (List_Error == NULL ||
+ PyDict_SetItemString(d, "Error", List_Error) != 0)
+ return;
+ List_Type.ob_type = &PyType_Type;
+ Py_INCREF(&List_Type);
+ if (PyDict_SetItemString(d, "ListType", (PyObject *)&List_Type) != 0)
+ Py_FatalError("can't initialize ListType");
+}
+
+/* ======================== End module _List ======================== */
+
--- /dev/null
+
+/* ========================== Module _Menu ========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Devices.h> /* Defines OpenDeskAcc in universal headers */
+#include <Menus.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+
+extern PyObject *_MenuObj_New(MenuHandle);
+extern int _MenuObj_Convert(PyObject *, MenuHandle *);
+
+#define MenuObj_New _MenuObj_New
+#define MenuObj_Convert _MenuObj_Convert
+#endif
+
+#if !ACCESSOR_CALLS_ARE_FUNCTIONS
+#define GetMenuID(menu) ((*(menu))->menuID)
+#define GetMenuWidth(menu) ((*(menu))->menuWidth)
+#define GetMenuHeight(menu) ((*(menu))->menuHeight)
+
+#define SetMenuID(menu, id) ((*(menu))->menuID = (id))
+#define SetMenuWidth(menu, width) ((*(menu))->menuWidth = (width))
+#define SetMenuHeight(menu, height) ((*(menu))->menuHeight = (height))
+#endif
+
+#define as_Menu(h) ((MenuHandle)h)
+#define as_Resource(h) ((Handle)h)
+
+static PyObject *Menu_Error;
+
+/* ------------------------ Object type Menu ------------------------ */
+
+PyTypeObject Menu_Type;
+
+#define MenuObj_Check(x) ((x)->ob_type == &Menu_Type)
+
+typedef struct MenuObject {
+ PyObject_HEAD
+ MenuHandle ob_itself;
+} MenuObject;
+
+PyObject *MenuObj_New(MenuHandle itself)
+{
+ MenuObject *it;
+ it = PyObject_NEW(MenuObject, &Menu_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+MenuObj_Convert(PyObject *v, MenuHandle *p_itself)
+{
+ if (!MenuObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "Menu required");
+ return 0;
+ }
+ *p_itself = ((MenuObject *)v)->ob_itself;
+ return 1;
+}
+
+static void MenuObj_dealloc(MenuObject *self)
+{
+ /* Cleanup of self->ob_itself goes here */
+ PyMem_DEL(self);
+}
+
+static PyObject *MenuObj_DisposeMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DisposeMenu(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_CalcMenuSize(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ CalcMenuSize(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_CountMenuItems(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CountMenuItems(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_CountMItems(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CountMItems(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *MenuObj_GetMenuFont(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ SInt16 outFontID;
+ UInt16 outFontSize;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetMenuFont(_self->ob_itself,
+ &outFontID,
+ &outFontSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("hH",
+ outFontID,
+ outFontSize);
+ return _res;
+}
+
+static PyObject *MenuObj_SetMenuFont(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ SInt16 inFontID;
+ UInt16 inFontSize;
+ if (!PyArg_ParseTuple(_args, "hH",
+ &inFontID,
+ &inFontSize))
+ return NULL;
+ _err = SetMenuFont(_self->ob_itself,
+ inFontID,
+ inFontSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetMenuExcludesMarkColumn(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMenuExcludesMarkColumn(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *MenuObj_SetMenuExcludesMarkColumn(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Boolean excludesMark;
+ if (!PyArg_ParseTuple(_args, "b",
+ &excludesMark))
+ return NULL;
+ _err = SetMenuExcludesMarkColumn(_self->ob_itself,
+ excludesMark);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_MacAppendMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Str255 data;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, data))
+ return NULL;
+ MacAppendMenu(_self->ob_itself,
+ data);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_InsertResMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ResType theType;
+ short afterItem;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetOSType, &theType,
+ &afterItem))
+ return NULL;
+ InsertResMenu(_self->ob_itself,
+ theType,
+ afterItem);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_AppendResMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ResType theType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theType))
+ return NULL;
+ AppendResMenu(_self->ob_itself,
+ theType);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_MacInsertMenuItem(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Str255 itemString;
+ short afterItem;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetStr255, itemString,
+ &afterItem))
+ return NULL;
+ MacInsertMenuItem(_self->ob_itself,
+ itemString,
+ afterItem);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_DeleteMenuItem(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ DeleteMenuItem(_self->ob_itself,
+ item);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_InsertFontResMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short afterItem;
+ short scriptFilter;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &afterItem,
+ &scriptFilter))
+ return NULL;
+ InsertFontResMenu(_self->ob_itself,
+ afterItem,
+ scriptFilter);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_InsertIntlResMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ResType theType;
+ short afterItem;
+ short scriptFilter;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetOSType, &theType,
+ &afterItem,
+ &scriptFilter))
+ return NULL;
+ InsertIntlResMenu(_self->ob_itself,
+ theType,
+ afterItem,
+ scriptFilter);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_AppendMenuItemText(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Str255 inString;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, inString))
+ return NULL;
+ _err = AppendMenuItemText(_self->ob_itself,
+ inString);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_InsertMenuItemText(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Str255 inString;
+ MenuItemIndex afterItem;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetStr255, inString,
+ &afterItem))
+ return NULL;
+ _err = InsertMenuItemText(_self->ob_itself,
+ inString,
+ afterItem);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_PopUpMenuSelect(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ short top;
+ short left;
+ short popUpItem;
+ if (!PyArg_ParseTuple(_args, "hhh",
+ &top,
+ &left,
+ &popUpItem))
+ return NULL;
+ _rv = PopUpMenuSelect(_self->ob_itself,
+ top,
+ left,
+ popUpItem);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MenuObj_MacInsertMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuID beforeID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &beforeID))
+ return NULL;
+ MacInsertMenu(_self->ob_itself,
+ beforeID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_MacCheckMenuItem(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ Boolean checked;
+ if (!PyArg_ParseTuple(_args, "hb",
+ &item,
+ &checked))
+ return NULL;
+ MacCheckMenuItem(_self->ob_itself,
+ item,
+ checked);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_CheckItem(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ Boolean checked;
+ if (!PyArg_ParseTuple(_args, "hb",
+ &item,
+ &checked))
+ return NULL;
+ CheckItem(_self->ob_itself,
+ item,
+ checked);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *MenuObj_SetMenuItemText(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ Str255 itemString;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &item,
+ PyMac_GetStr255, itemString))
+ return NULL;
+ SetMenuItemText(_self->ob_itself,
+ item,
+ itemString);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemText(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ Str255 itemString;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ GetMenuItemText(_self->ob_itself,
+ item,
+ itemString);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildStr255, itemString);
+ return _res;
+}
+
+static PyObject *MenuObj_SetItemMark(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ CharParameter markChar;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &item,
+ &markChar))
+ return NULL;
+ SetItemMark(_self->ob_itself,
+ item,
+ markChar);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetItemMark(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ CharParameter markChar;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ GetItemMark(_self->ob_itself,
+ item,
+ &markChar);
+ _res = Py_BuildValue("h",
+ markChar);
+ return _res;
+}
+
+static PyObject *MenuObj_SetItemCmd(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ CharParameter cmdChar;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &item,
+ &cmdChar))
+ return NULL;
+ SetItemCmd(_self->ob_itself,
+ item,
+ cmdChar);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetItemCmd(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ CharParameter cmdChar;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ GetItemCmd(_self->ob_itself,
+ item,
+ &cmdChar);
+ _res = Py_BuildValue("h",
+ cmdChar);
+ return _res;
+}
+
+static PyObject *MenuObj_SetItemIcon(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ short iconIndex;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &item,
+ &iconIndex))
+ return NULL;
+ SetItemIcon(_self->ob_itself,
+ item,
+ iconIndex);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetItemIcon(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ short iconIndex;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ GetItemIcon(_self->ob_itself,
+ item,
+ &iconIndex);
+ _res = Py_BuildValue("h",
+ iconIndex);
+ return _res;
+}
+
+static PyObject *MenuObj_SetItemStyle(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ StyleParameter chStyle;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &item,
+ &chStyle))
+ return NULL;
+ SetItemStyle(_self->ob_itself,
+ item,
+ chStyle);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetItemStyle(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ Style chStyle;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ GetItemStyle(_self->ob_itself,
+ item,
+ &chStyle);
+ _res = Py_BuildValue("b",
+ chStyle);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_DisableItem(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ DisableItem(_self->ob_itself,
+ item);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_EnableItem(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ EnableItem(_self->ob_itself,
+ item);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *MenuObj_SetMenuItemCommandID(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ MenuCommand inCommandID;
+ if (!PyArg_ParseTuple(_args, "hl",
+ &inItem,
+ &inCommandID))
+ return NULL;
+ _err = SetMenuItemCommandID(_self->ob_itself,
+ inItem,
+ inCommandID);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemCommandID(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ MenuCommand outCommandID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &inItem))
+ return NULL;
+ _err = GetMenuItemCommandID(_self->ob_itself,
+ inItem,
+ &outCommandID);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outCommandID);
+ return _res;
+}
+
+static PyObject *MenuObj_SetMenuItemModifiers(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ UInt8 inModifiers;
+ if (!PyArg_ParseTuple(_args, "hb",
+ &inItem,
+ &inModifiers))
+ return NULL;
+ _err = SetMenuItemModifiers(_self->ob_itself,
+ inItem,
+ inModifiers);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemModifiers(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ UInt8 outModifiers;
+ if (!PyArg_ParseTuple(_args, "h",
+ &inItem))
+ return NULL;
+ _err = GetMenuItemModifiers(_self->ob_itself,
+ inItem,
+ &outModifiers);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("b",
+ outModifiers);
+ return _res;
+}
+
+static PyObject *MenuObj_SetMenuItemIconHandle(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ UInt8 inIconType;
+ Handle inIconHandle;
+ if (!PyArg_ParseTuple(_args, "hbO&",
+ &inItem,
+ &inIconType,
+ ResObj_Convert, &inIconHandle))
+ return NULL;
+ _err = SetMenuItemIconHandle(_self->ob_itself,
+ inItem,
+ inIconType,
+ inIconHandle);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemIconHandle(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ UInt8 outIconType;
+ Handle outIconHandle;
+ if (!PyArg_ParseTuple(_args, "h",
+ &inItem))
+ return NULL;
+ _err = GetMenuItemIconHandle(_self->ob_itself,
+ inItem,
+ &outIconType,
+ &outIconHandle);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("bO&",
+ outIconType,
+ ResObj_New, outIconHandle);
+ return _res;
+}
+
+static PyObject *MenuObj_SetMenuItemTextEncoding(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ TextEncoding inScriptID;
+ if (!PyArg_ParseTuple(_args, "hl",
+ &inItem,
+ &inScriptID))
+ return NULL;
+ _err = SetMenuItemTextEncoding(_self->ob_itself,
+ inItem,
+ inScriptID);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemTextEncoding(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ TextEncoding outScriptID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &inItem))
+ return NULL;
+ _err = GetMenuItemTextEncoding(_self->ob_itself,
+ inItem,
+ &outScriptID);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outScriptID);
+ return _res;
+}
+
+static PyObject *MenuObj_SetMenuItemHierarchicalID(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ MenuID inHierID;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &inItem,
+ &inHierID))
+ return NULL;
+ _err = SetMenuItemHierarchicalID(_self->ob_itself,
+ inItem,
+ inHierID);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemHierarchicalID(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ MenuID outHierID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &inItem))
+ return NULL;
+ _err = GetMenuItemHierarchicalID(_self->ob_itself,
+ inItem,
+ &outHierID);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ outHierID);
+ return _res;
+}
+
+static PyObject *MenuObj_SetMenuItemFontID(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ SInt16 inFontID;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &inItem,
+ &inFontID))
+ return NULL;
+ _err = SetMenuItemFontID(_self->ob_itself,
+ inItem,
+ inFontID);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemFontID(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ SInt16 outFontID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &inItem))
+ return NULL;
+ _err = GetMenuItemFontID(_self->ob_itself,
+ inItem,
+ &outFontID);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ outFontID);
+ return _res;
+}
+
+static PyObject *MenuObj_SetMenuItemRefCon(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ UInt32 inRefCon;
+ if (!PyArg_ParseTuple(_args, "hl",
+ &inItem,
+ &inRefCon))
+ return NULL;
+ _err = SetMenuItemRefCon(_self->ob_itself,
+ inItem,
+ inRefCon);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemRefCon(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ UInt32 outRefCon;
+ if (!PyArg_ParseTuple(_args, "h",
+ &inItem))
+ return NULL;
+ _err = GetMenuItemRefCon(_self->ob_itself,
+ inItem,
+ &outRefCon);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outRefCon);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_SetMenuItemRefCon2(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ UInt32 inRefCon2;
+ if (!PyArg_ParseTuple(_args, "hl",
+ &inItem,
+ &inRefCon2))
+ return NULL;
+ _err = SetMenuItemRefCon2(_self->ob_itself,
+ inItem,
+ inRefCon2);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_GetMenuItemRefCon2(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ UInt32 outRefCon2;
+ if (!PyArg_ParseTuple(_args, "h",
+ &inItem))
+ return NULL;
+ _err = GetMenuItemRefCon2(_self->ob_itself,
+ inItem,
+ &outRefCon2);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outRefCon2);
+ return _res;
+}
+#endif
+
+static PyObject *MenuObj_SetMenuItemKeyGlyph(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ SInt16 inGlyph;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &inItem,
+ &inGlyph))
+ return NULL;
+ _err = SetMenuItemKeyGlyph(_self->ob_itself,
+ inItem,
+ inGlyph);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemKeyGlyph(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SInt16 inItem;
+ SInt16 outGlyph;
+ if (!PyArg_ParseTuple(_args, "h",
+ &inItem))
+ return NULL;
+ _err = GetMenuItemKeyGlyph(_self->ob_itself,
+ inItem,
+ &outGlyph);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ outGlyph);
+ return _res;
+}
+
+static PyObject *MenuObj_MacEnableMenuItem(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuItemIndex item;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ MacEnableMenuItem(_self->ob_itself,
+ item);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_DisableMenuItem(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuItemIndex item;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ DisableMenuItem(_self->ob_itself,
+ item);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_IsMenuItemEnabled(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ MenuItemIndex item;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ _rv = IsMenuItemEnabled(_self->ob_itself,
+ item);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *MenuObj_EnableMenuItemIcon(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuItemIndex item;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ EnableMenuItemIcon(_self->ob_itself,
+ item);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_DisableMenuItemIcon(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuItemIndex item;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ DisableMenuItemIcon(_self->ob_itself,
+ item);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_IsMenuItemIconEnabled(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ MenuItemIndex item;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ _rv = IsMenuItemIconEnabled(_self->ob_itself,
+ item);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_GetMenuItemPropertyAttributes(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex item;
+ OSType propertyCreator;
+ OSType propertyTag;
+ UInt32 attributes;
+ if (!PyArg_ParseTuple(_args, "hO&O&",
+ &item,
+ PyMac_GetOSType, &propertyCreator,
+ PyMac_GetOSType, &propertyTag))
+ return NULL;
+ _err = GetMenuItemPropertyAttributes(_self->ob_itself,
+ item,
+ propertyCreator,
+ propertyTag,
+ &attributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ attributes);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_ChangeMenuItemPropertyAttributes(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex item;
+ OSType propertyCreator;
+ OSType propertyTag;
+ UInt32 attributesToSet;
+ UInt32 attributesToClear;
+ if (!PyArg_ParseTuple(_args, "hO&O&ll",
+ &item,
+ PyMac_GetOSType, &propertyCreator,
+ PyMac_GetOSType, &propertyTag,
+ &attributesToSet,
+ &attributesToClear))
+ return NULL;
+ _err = ChangeMenuItemPropertyAttributes(_self->ob_itself,
+ item,
+ propertyCreator,
+ propertyTag,
+ attributesToSet,
+ attributesToClear);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_GetMenuAttributes(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuAttributes outAttributes;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetMenuAttributes(_self->ob_itself,
+ &outAttributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outAttributes);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_ChangeMenuAttributes(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuAttributes setTheseAttributes;
+ MenuAttributes clearTheseAttributes;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &setTheseAttributes,
+ &clearTheseAttributes))
+ return NULL;
+ _err = ChangeMenuAttributes(_self->ob_itself,
+ setTheseAttributes,
+ clearTheseAttributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_GetMenuItemAttributes(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex item;
+ MenuItemAttributes outAttributes;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ _err = GetMenuItemAttributes(_self->ob_itself,
+ item,
+ &outAttributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outAttributes);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_ChangeMenuItemAttributes(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex item;
+ MenuItemAttributes setTheseAttributes;
+ MenuItemAttributes clearTheseAttributes;
+ if (!PyArg_ParseTuple(_args, "hll",
+ &item,
+ &setTheseAttributes,
+ &clearTheseAttributes))
+ return NULL;
+ _err = ChangeMenuItemAttributes(_self->ob_itself,
+ item,
+ setTheseAttributes,
+ clearTheseAttributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_DisableAllMenuItems(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DisableAllMenuItems(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_EnableAllMenuItems(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ EnableAllMenuItems(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_MenuHasEnabledItems(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MenuHasEnabledItems(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_CountMenuItemsWithCommandID(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ItemCount _rv;
+ MenuCommand commandID;
+ if (!PyArg_ParseTuple(_args, "l",
+ &commandID))
+ return NULL;
+ _rv = CountMenuItemsWithCommandID(_self->ob_itself,
+ commandID);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_GetIndMenuItemWithCommandID(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuCommand commandID;
+ UInt32 itemIndex;
+ MenuHandle outMenu;
+ MenuItemIndex outIndex;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &commandID,
+ &itemIndex))
+ return NULL;
+ _err = GetIndMenuItemWithCommandID(_self->ob_itself,
+ commandID,
+ itemIndex,
+ &outMenu,
+ &outIndex);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&h",
+ MenuObj_New, outMenu,
+ outIndex);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_EnableMenuCommand(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuCommand commandID;
+ if (!PyArg_ParseTuple(_args, "l",
+ &commandID))
+ return NULL;
+ EnableMenuCommand(_self->ob_itself,
+ commandID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_DisableMenuCommand(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuCommand commandID;
+ if (!PyArg_ParseTuple(_args, "l",
+ &commandID))
+ return NULL;
+ DisableMenuCommand(_self->ob_itself,
+ commandID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_IsMenuCommandEnabled(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ MenuCommand commandID;
+ if (!PyArg_ParseTuple(_args, "l",
+ &commandID))
+ return NULL;
+ _rv = IsMenuCommandEnabled(_self->ob_itself,
+ commandID);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_GetMenuCommandPropertySize(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuCommand commandID;
+ OSType propertyCreator;
+ OSType propertyTag;
+ ByteCount size;
+ if (!PyArg_ParseTuple(_args, "lO&O&",
+ &commandID,
+ PyMac_GetOSType, &propertyCreator,
+ PyMac_GetOSType, &propertyTag))
+ return NULL;
+ _err = GetMenuCommandPropertySize(_self->ob_itself,
+ commandID,
+ propertyCreator,
+ propertyTag,
+ &size);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ size);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_RemoveMenuCommandProperty(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuCommand commandID;
+ OSType propertyCreator;
+ OSType propertyTag;
+ if (!PyArg_ParseTuple(_args, "lO&O&",
+ &commandID,
+ PyMac_GetOSType, &propertyCreator,
+ PyMac_GetOSType, &propertyTag))
+ return NULL;
+ _err = RemoveMenuCommandProperty(_self->ob_itself,
+ commandID,
+ propertyCreator,
+ propertyTag);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_CreateStandardFontMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex afterItem;
+ MenuID firstHierMenuID;
+ OptionBits options;
+ ItemCount outHierMenuCount;
+ if (!PyArg_ParseTuple(_args, "hhl",
+ &afterItem,
+ &firstHierMenuID,
+ &options))
+ return NULL;
+ _err = CreateStandardFontMenu(_self->ob_itself,
+ afterItem,
+ firstHierMenuID,
+ options,
+ &outHierMenuCount);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outHierMenuCount);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_UpdateStandardFontMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ItemCount outHierMenuCount;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = UpdateStandardFontMenu(_self->ob_itself,
+ &outHierMenuCount);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outHierMenuCount);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_GetFontFamilyFromMenuSelection(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex item;
+ FMFontFamily outFontFamily;
+ FMFontStyle outStyle;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ _err = GetFontFamilyFromMenuSelection(_self->ob_itself,
+ item,
+ &outFontFamily,
+ &outStyle);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("hh",
+ outFontFamily,
+ outStyle);
+ return _res;
+}
+#endif
+
+static PyObject *MenuObj_GetMenuID(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuID _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMenuID(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *MenuObj_GetMenuWidth(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMenuWidth(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *MenuObj_GetMenuHeight(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMenuHeight(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *MenuObj_SetMenuID(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuID menuID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &menuID))
+ return NULL;
+ SetMenuID(_self->ob_itself,
+ menuID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_SetMenuWidth(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 width;
+ if (!PyArg_ParseTuple(_args, "h",
+ &width))
+ return NULL;
+ SetMenuWidth(_self->ob_itself,
+ width);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_SetMenuHeight(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 height;
+ if (!PyArg_ParseTuple(_args, "h",
+ &height))
+ return NULL;
+ SetMenuHeight(_self->ob_itself,
+ height);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_as_Resource(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = as_Resource(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MenuObj_AppendMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Str255 data;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, data))
+ return NULL;
+ AppendMenu(_self->ob_itself,
+ data);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_InsertMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short beforeID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &beforeID))
+ return NULL;
+ InsertMenu(_self->ob_itself,
+ beforeID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_InsertMenuItem(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Str255 itemString;
+ short afterItem;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetStr255, itemString,
+ &afterItem))
+ return NULL;
+ InsertMenuItem(_self->ob_itself,
+ itemString,
+ afterItem);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_EnableMenuItem(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt16 item;
+ if (!PyArg_ParseTuple(_args, "H",
+ &item))
+ return NULL;
+ EnableMenuItem(_self->ob_itself,
+ item);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_CheckMenuItem(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short item;
+ Boolean checked;
+ if (!PyArg_ParseTuple(_args, "hb",
+ &item,
+ &checked))
+ return NULL;
+ CheckMenuItem(_self->ob_itself,
+ item,
+ checked);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef MenuObj_methods[] = {
+ {"DisposeMenu", (PyCFunction)MenuObj_DisposeMenu, 1,
+ "() -> None"},
+ {"CalcMenuSize", (PyCFunction)MenuObj_CalcMenuSize, 1,
+ "() -> None"},
+ {"CountMenuItems", (PyCFunction)MenuObj_CountMenuItems, 1,
+ "() -> (short _rv)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"CountMItems", (PyCFunction)MenuObj_CountMItems, 1,
+ "() -> (short _rv)"},
+#endif
+ {"GetMenuFont", (PyCFunction)MenuObj_GetMenuFont, 1,
+ "() -> (SInt16 outFontID, UInt16 outFontSize)"},
+ {"SetMenuFont", (PyCFunction)MenuObj_SetMenuFont, 1,
+ "(SInt16 inFontID, UInt16 inFontSize) -> None"},
+ {"GetMenuExcludesMarkColumn", (PyCFunction)MenuObj_GetMenuExcludesMarkColumn, 1,
+ "() -> (Boolean _rv)"},
+ {"SetMenuExcludesMarkColumn", (PyCFunction)MenuObj_SetMenuExcludesMarkColumn, 1,
+ "(Boolean excludesMark) -> None"},
+ {"MacAppendMenu", (PyCFunction)MenuObj_MacAppendMenu, 1,
+ "(Str255 data) -> None"},
+ {"InsertResMenu", (PyCFunction)MenuObj_InsertResMenu, 1,
+ "(ResType theType, short afterItem) -> None"},
+ {"AppendResMenu", (PyCFunction)MenuObj_AppendResMenu, 1,
+ "(ResType theType) -> None"},
+ {"MacInsertMenuItem", (PyCFunction)MenuObj_MacInsertMenuItem, 1,
+ "(Str255 itemString, short afterItem) -> None"},
+ {"DeleteMenuItem", (PyCFunction)MenuObj_DeleteMenuItem, 1,
+ "(short item) -> None"},
+ {"InsertFontResMenu", (PyCFunction)MenuObj_InsertFontResMenu, 1,
+ "(short afterItem, short scriptFilter) -> None"},
+ {"InsertIntlResMenu", (PyCFunction)MenuObj_InsertIntlResMenu, 1,
+ "(ResType theType, short afterItem, short scriptFilter) -> None"},
+ {"AppendMenuItemText", (PyCFunction)MenuObj_AppendMenuItemText, 1,
+ "(Str255 inString) -> None"},
+ {"InsertMenuItemText", (PyCFunction)MenuObj_InsertMenuItemText, 1,
+ "(Str255 inString, MenuItemIndex afterItem) -> None"},
+ {"PopUpMenuSelect", (PyCFunction)MenuObj_PopUpMenuSelect, 1,
+ "(short top, short left, short popUpItem) -> (long _rv)"},
+ {"MacInsertMenu", (PyCFunction)MenuObj_MacInsertMenu, 1,
+ "(MenuID beforeID) -> None"},
+ {"MacCheckMenuItem", (PyCFunction)MenuObj_MacCheckMenuItem, 1,
+ "(short item, Boolean checked) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+ {"CheckItem", (PyCFunction)MenuObj_CheckItem, 1,
+ "(short item, Boolean checked) -> None"},
+#endif
+ {"SetMenuItemText", (PyCFunction)MenuObj_SetMenuItemText, 1,
+ "(short item, Str255 itemString) -> None"},
+ {"GetMenuItemText", (PyCFunction)MenuObj_GetMenuItemText, 1,
+ "(short item) -> (Str255 itemString)"},
+ {"SetItemMark", (PyCFunction)MenuObj_SetItemMark, 1,
+ "(short item, CharParameter markChar) -> None"},
+ {"GetItemMark", (PyCFunction)MenuObj_GetItemMark, 1,
+ "(short item) -> (CharParameter markChar)"},
+ {"SetItemCmd", (PyCFunction)MenuObj_SetItemCmd, 1,
+ "(short item, CharParameter cmdChar) -> None"},
+ {"GetItemCmd", (PyCFunction)MenuObj_GetItemCmd, 1,
+ "(short item) -> (CharParameter cmdChar)"},
+ {"SetItemIcon", (PyCFunction)MenuObj_SetItemIcon, 1,
+ "(short item, short iconIndex) -> None"},
+ {"GetItemIcon", (PyCFunction)MenuObj_GetItemIcon, 1,
+ "(short item) -> (short iconIndex)"},
+ {"SetItemStyle", (PyCFunction)MenuObj_SetItemStyle, 1,
+ "(short item, StyleParameter chStyle) -> None"},
+ {"GetItemStyle", (PyCFunction)MenuObj_GetItemStyle, 1,
+ "(short item) -> (Style chStyle)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"DisableItem", (PyCFunction)MenuObj_DisableItem, 1,
+ "(short item) -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"EnableItem", (PyCFunction)MenuObj_EnableItem, 1,
+ "(short item) -> None"},
+#endif
+ {"SetMenuItemCommandID", (PyCFunction)MenuObj_SetMenuItemCommandID, 1,
+ "(SInt16 inItem, MenuCommand inCommandID) -> None"},
+ {"GetMenuItemCommandID", (PyCFunction)MenuObj_GetMenuItemCommandID, 1,
+ "(SInt16 inItem) -> (MenuCommand outCommandID)"},
+ {"SetMenuItemModifiers", (PyCFunction)MenuObj_SetMenuItemModifiers, 1,
+ "(SInt16 inItem, UInt8 inModifiers) -> None"},
+ {"GetMenuItemModifiers", (PyCFunction)MenuObj_GetMenuItemModifiers, 1,
+ "(SInt16 inItem) -> (UInt8 outModifiers)"},
+ {"SetMenuItemIconHandle", (PyCFunction)MenuObj_SetMenuItemIconHandle, 1,
+ "(SInt16 inItem, UInt8 inIconType, Handle inIconHandle) -> None"},
+ {"GetMenuItemIconHandle", (PyCFunction)MenuObj_GetMenuItemIconHandle, 1,
+ "(SInt16 inItem) -> (UInt8 outIconType, Handle outIconHandle)"},
+ {"SetMenuItemTextEncoding", (PyCFunction)MenuObj_SetMenuItemTextEncoding, 1,
+ "(SInt16 inItem, TextEncoding inScriptID) -> None"},
+ {"GetMenuItemTextEncoding", (PyCFunction)MenuObj_GetMenuItemTextEncoding, 1,
+ "(SInt16 inItem) -> (TextEncoding outScriptID)"},
+ {"SetMenuItemHierarchicalID", (PyCFunction)MenuObj_SetMenuItemHierarchicalID, 1,
+ "(SInt16 inItem, MenuID inHierID) -> None"},
+ {"GetMenuItemHierarchicalID", (PyCFunction)MenuObj_GetMenuItemHierarchicalID, 1,
+ "(SInt16 inItem) -> (MenuID outHierID)"},
+ {"SetMenuItemFontID", (PyCFunction)MenuObj_SetMenuItemFontID, 1,
+ "(SInt16 inItem, SInt16 inFontID) -> None"},
+ {"GetMenuItemFontID", (PyCFunction)MenuObj_GetMenuItemFontID, 1,
+ "(SInt16 inItem) -> (SInt16 outFontID)"},
+ {"SetMenuItemRefCon", (PyCFunction)MenuObj_SetMenuItemRefCon, 1,
+ "(SInt16 inItem, UInt32 inRefCon) -> None"},
+ {"GetMenuItemRefCon", (PyCFunction)MenuObj_GetMenuItemRefCon, 1,
+ "(SInt16 inItem) -> (UInt32 outRefCon)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"SetMenuItemRefCon2", (PyCFunction)MenuObj_SetMenuItemRefCon2, 1,
+ "(SInt16 inItem, UInt32 inRefCon2) -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"GetMenuItemRefCon2", (PyCFunction)MenuObj_GetMenuItemRefCon2, 1,
+ "(SInt16 inItem) -> (UInt32 outRefCon2)"},
+#endif
+ {"SetMenuItemKeyGlyph", (PyCFunction)MenuObj_SetMenuItemKeyGlyph, 1,
+ "(SInt16 inItem, SInt16 inGlyph) -> None"},
+ {"GetMenuItemKeyGlyph", (PyCFunction)MenuObj_GetMenuItemKeyGlyph, 1,
+ "(SInt16 inItem) -> (SInt16 outGlyph)"},
+ {"MacEnableMenuItem", (PyCFunction)MenuObj_MacEnableMenuItem, 1,
+ "(MenuItemIndex item) -> None"},
+ {"DisableMenuItem", (PyCFunction)MenuObj_DisableMenuItem, 1,
+ "(MenuItemIndex item) -> None"},
+ {"IsMenuItemEnabled", (PyCFunction)MenuObj_IsMenuItemEnabled, 1,
+ "(MenuItemIndex item) -> (Boolean _rv)"},
+ {"EnableMenuItemIcon", (PyCFunction)MenuObj_EnableMenuItemIcon, 1,
+ "(MenuItemIndex item) -> None"},
+ {"DisableMenuItemIcon", (PyCFunction)MenuObj_DisableMenuItemIcon, 1,
+ "(MenuItemIndex item) -> None"},
+ {"IsMenuItemIconEnabled", (PyCFunction)MenuObj_IsMenuItemIconEnabled, 1,
+ "(MenuItemIndex item) -> (Boolean _rv)"},
+
+#if TARGET_API_MAC_CARBON
+ {"GetMenuItemPropertyAttributes", (PyCFunction)MenuObj_GetMenuItemPropertyAttributes, 1,
+ "(MenuItemIndex item, OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"ChangeMenuItemPropertyAttributes", (PyCFunction)MenuObj_ChangeMenuItemPropertyAttributes, 1,
+ "(MenuItemIndex item, OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetMenuAttributes", (PyCFunction)MenuObj_GetMenuAttributes, 1,
+ "() -> (MenuAttributes outAttributes)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"ChangeMenuAttributes", (PyCFunction)MenuObj_ChangeMenuAttributes, 1,
+ "(MenuAttributes setTheseAttributes, MenuAttributes clearTheseAttributes) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetMenuItemAttributes", (PyCFunction)MenuObj_GetMenuItemAttributes, 1,
+ "(MenuItemIndex item) -> (MenuItemAttributes outAttributes)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"ChangeMenuItemAttributes", (PyCFunction)MenuObj_ChangeMenuItemAttributes, 1,
+ "(MenuItemIndex item, MenuItemAttributes setTheseAttributes, MenuItemAttributes clearTheseAttributes) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"DisableAllMenuItems", (PyCFunction)MenuObj_DisableAllMenuItems, 1,
+ "() -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"EnableAllMenuItems", (PyCFunction)MenuObj_EnableAllMenuItems, 1,
+ "() -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"MenuHasEnabledItems", (PyCFunction)MenuObj_MenuHasEnabledItems, 1,
+ "() -> (Boolean _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"CountMenuItemsWithCommandID", (PyCFunction)MenuObj_CountMenuItemsWithCommandID, 1,
+ "(MenuCommand commandID) -> (ItemCount _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetIndMenuItemWithCommandID", (PyCFunction)MenuObj_GetIndMenuItemWithCommandID, 1,
+ "(MenuCommand commandID, UInt32 itemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"EnableMenuCommand", (PyCFunction)MenuObj_EnableMenuCommand, 1,
+ "(MenuCommand commandID) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"DisableMenuCommand", (PyCFunction)MenuObj_DisableMenuCommand, 1,
+ "(MenuCommand commandID) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"IsMenuCommandEnabled", (PyCFunction)MenuObj_IsMenuCommandEnabled, 1,
+ "(MenuCommand commandID) -> (Boolean _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetMenuCommandPropertySize", (PyCFunction)MenuObj_GetMenuCommandPropertySize, 1,
+ "(MenuCommand commandID, OSType propertyCreator, OSType propertyTag) -> (ByteCount size)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"RemoveMenuCommandProperty", (PyCFunction)MenuObj_RemoveMenuCommandProperty, 1,
+ "(MenuCommand commandID, OSType propertyCreator, OSType propertyTag) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"CreateStandardFontMenu", (PyCFunction)MenuObj_CreateStandardFontMenu, 1,
+ "(MenuItemIndex afterItem, MenuID firstHierMenuID, OptionBits options) -> (ItemCount outHierMenuCount)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"UpdateStandardFontMenu", (PyCFunction)MenuObj_UpdateStandardFontMenu, 1,
+ "() -> (ItemCount outHierMenuCount)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetFontFamilyFromMenuSelection", (PyCFunction)MenuObj_GetFontFamilyFromMenuSelection, 1,
+ "(MenuItemIndex item) -> (FMFontFamily outFontFamily, FMFontStyle outStyle)"},
+#endif
+ {"GetMenuID", (PyCFunction)MenuObj_GetMenuID, 1,
+ "() -> (MenuID _rv)"},
+ {"GetMenuWidth", (PyCFunction)MenuObj_GetMenuWidth, 1,
+ "() -> (SInt16 _rv)"},
+ {"GetMenuHeight", (PyCFunction)MenuObj_GetMenuHeight, 1,
+ "() -> (SInt16 _rv)"},
+ {"SetMenuID", (PyCFunction)MenuObj_SetMenuID, 1,
+ "(MenuID menuID) -> None"},
+ {"SetMenuWidth", (PyCFunction)MenuObj_SetMenuWidth, 1,
+ "(SInt16 width) -> None"},
+ {"SetMenuHeight", (PyCFunction)MenuObj_SetMenuHeight, 1,
+ "(SInt16 height) -> None"},
+ {"as_Resource", (PyCFunction)MenuObj_as_Resource, 1,
+ "() -> (Handle _rv)"},
+ {"AppendMenu", (PyCFunction)MenuObj_AppendMenu, 1,
+ "(Str255 data) -> None"},
+ {"InsertMenu", (PyCFunction)MenuObj_InsertMenu, 1,
+ "(short beforeID) -> None"},
+ {"InsertMenuItem", (PyCFunction)MenuObj_InsertMenuItem, 1,
+ "(Str255 itemString, short afterItem) -> None"},
+ {"EnableMenuItem", (PyCFunction)MenuObj_EnableMenuItem, 1,
+ "(UInt16 item) -> None"},
+ {"CheckMenuItem", (PyCFunction)MenuObj_CheckMenuItem, 1,
+ "(short item, Boolean checked) -> None"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain MenuObj_chain = { MenuObj_methods, NULL };
+
+static PyObject *MenuObj_getattr(MenuObject *self, char *name)
+{
+ return Py_FindMethodInChain(&MenuObj_chain, (PyObject *)self, name);
+}
+
+#define MenuObj_setattr NULL
+
+#define MenuObj_compare NULL
+
+#define MenuObj_repr NULL
+
+#define MenuObj_hash NULL
+
+PyTypeObject Menu_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "Menu", /*tp_name*/
+ sizeof(MenuObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) MenuObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) MenuObj_getattr, /*tp_getattr*/
+ (setattrfunc) MenuObj_setattr, /*tp_setattr*/
+ (cmpfunc) MenuObj_compare, /*tp_compare*/
+ (reprfunc) MenuObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) MenuObj_hash, /*tp_hash*/
+};
+
+/* ---------------------- End object type Menu ---------------------- */
+
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Menu_InitProcMenu(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short resID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &resID))
+ return NULL;
+ InitProcMenu(resID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Menu_InitMenus(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ InitMenus();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Menu_NewMenu(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuHandle _rv;
+ MenuID menuID;
+ Str255 menuTitle;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &menuID,
+ PyMac_GetStr255, menuTitle))
+ return NULL;
+ _rv = NewMenu(menuID,
+ menuTitle);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Menu_MacGetMenu(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuHandle _rv;
+ short resourceID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &resourceID))
+ return NULL;
+ _rv = MacGetMenu(resourceID);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, _rv);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Menu_CreateNewMenu(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuID menuID;
+ MenuAttributes menuAttributes;
+ MenuHandle outMenuRef;
+ if (!PyArg_ParseTuple(_args, "hl",
+ &menuID,
+ &menuAttributes))
+ return NULL;
+ _err = CreateNewMenu(menuID,
+ menuAttributes,
+ &outMenuRef);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, outMenuRef);
+ return _res;
+}
+#endif
+
+static PyObject *Menu_MenuKey(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ CharParameter ch;
+ if (!PyArg_ParseTuple(_args, "h",
+ &ch))
+ return NULL;
+ _rv = MenuKey(ch);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Menu_MenuSelect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ Point startPt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &startPt))
+ return NULL;
+ _rv = MenuSelect(startPt);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Menu_MenuChoice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MenuChoice();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Menu_MenuEvent(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt32 _rv;
+ EventRecord inEvent;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &inEvent))
+ return NULL;
+ _rv = MenuEvent(&inEvent);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Menu_GetMBarHeight(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMBarHeight();
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Menu_MacDrawMenuBar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ MacDrawMenuBar();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_InvalMenuBar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ InvalMenuBar();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_HiliteMenu(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuID menuID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &menuID))
+ return NULL;
+ HiliteMenu(menuID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_GetNewMBar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuBarHandle _rv;
+ short menuBarID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &menuBarID))
+ return NULL;
+ _rv = GetNewMBar(menuBarID);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Menu_GetMenuBar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuBarHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMenuBar();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Menu_SetMenuBar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuBarHandle mbar;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &mbar))
+ return NULL;
+ SetMenuBar(mbar);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Menu_DuplicateMenuBar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuBarHandle mbar;
+ MenuBarHandle outBar;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &mbar))
+ return NULL;
+ _err = DuplicateMenuBar(mbar,
+ &outBar);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, outBar);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Menu_DisposeMenuBar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuBarHandle mbar;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &mbar))
+ return NULL;
+ _err = DisposeMenuBar(mbar);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Menu_GetMenuHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuHandle _rv;
+ MenuID menuID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &menuID))
+ return NULL;
+ _rv = GetMenuHandle(menuID);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Menu_MacDeleteMenu(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuID menuID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &menuID))
+ return NULL;
+ MacDeleteMenu(menuID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_ClearMenuBar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ClearMenuBar();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_SetMenuFlashCount(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short count;
+ if (!PyArg_ParseTuple(_args, "h",
+ &count))
+ return NULL;
+ SetMenuFlashCount(count);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Menu_SetMenuFlash(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short count;
+ if (!PyArg_ParseTuple(_args, "h",
+ &count))
+ return NULL;
+ SetMenuFlash(count);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Menu_FlashMenuBar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuID menuID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &menuID))
+ return NULL;
+ FlashMenuBar(menuID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Menu_SystemEdit(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ short editCmd;
+ if (!PyArg_ParseTuple(_args, "h",
+ &editCmd))
+ return NULL;
+ _rv = SystemEdit(editCmd);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Menu_SystemMenu(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long menuResult;
+ if (!PyArg_ParseTuple(_args, "l",
+ &menuResult))
+ return NULL;
+ SystemMenu(menuResult);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Menu_IsMenuBarVisible(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsMenuBarVisible();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Menu_ShowMenuBar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ShowMenuBar();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_HideMenuBar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ HideMenuBar();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_DeleteMCEntries(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuID menuID;
+ short menuItem;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &menuID,
+ &menuItem))
+ return NULL;
+ DeleteMCEntries(menuID,
+ menuItem);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_InitContextualMenus(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = InitContextualMenus();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_IsShowContextualMenuClick(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventRecord inEvent;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &inEvent))
+ return NULL;
+ _rv = IsShowContextualMenuClick(&inEvent);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Menu_OpenDeskAcc(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Str255 name;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, name))
+ return NULL;
+ OpenDeskAcc(name);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Menu_as_Menu(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuHandle _rv;
+ Handle h;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &h))
+ return NULL;
+ _rv = as_Menu(h);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Menu_GetMenu(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuHandle _rv;
+ short resourceID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &resourceID))
+ return NULL;
+ _rv = GetMenu(resourceID);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Menu_DeleteMenu(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short menuID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &menuID))
+ return NULL;
+ DeleteMenu(menuID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_DrawMenuBar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DrawMenuBar();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef Menu_methods[] = {
+
+#if !TARGET_API_MAC_CARBON
+ {"InitProcMenu", (PyCFunction)Menu_InitProcMenu, 1,
+ "(short resID) -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"InitMenus", (PyCFunction)Menu_InitMenus, 1,
+ "() -> None"},
+#endif
+ {"NewMenu", (PyCFunction)Menu_NewMenu, 1,
+ "(MenuID menuID, Str255 menuTitle) -> (MenuHandle _rv)"},
+ {"MacGetMenu", (PyCFunction)Menu_MacGetMenu, 1,
+ "(short resourceID) -> (MenuHandle _rv)"},
+
+#if TARGET_API_MAC_CARBON
+ {"CreateNewMenu", (PyCFunction)Menu_CreateNewMenu, 1,
+ "(MenuID menuID, MenuAttributes menuAttributes) -> (MenuHandle outMenuRef)"},
+#endif
+ {"MenuKey", (PyCFunction)Menu_MenuKey, 1,
+ "(CharParameter ch) -> (long _rv)"},
+ {"MenuSelect", (PyCFunction)Menu_MenuSelect, 1,
+ "(Point startPt) -> (long _rv)"},
+ {"MenuChoice", (PyCFunction)Menu_MenuChoice, 1,
+ "() -> (long _rv)"},
+ {"MenuEvent", (PyCFunction)Menu_MenuEvent, 1,
+ "(EventRecord inEvent) -> (UInt32 _rv)"},
+ {"GetMBarHeight", (PyCFunction)Menu_GetMBarHeight, 1,
+ "() -> (short _rv)"},
+ {"MacDrawMenuBar", (PyCFunction)Menu_MacDrawMenuBar, 1,
+ "() -> None"},
+ {"InvalMenuBar", (PyCFunction)Menu_InvalMenuBar, 1,
+ "() -> None"},
+ {"HiliteMenu", (PyCFunction)Menu_HiliteMenu, 1,
+ "(MenuID menuID) -> None"},
+ {"GetNewMBar", (PyCFunction)Menu_GetNewMBar, 1,
+ "(short menuBarID) -> (MenuBarHandle _rv)"},
+ {"GetMenuBar", (PyCFunction)Menu_GetMenuBar, 1,
+ "() -> (MenuBarHandle _rv)"},
+ {"SetMenuBar", (PyCFunction)Menu_SetMenuBar, 1,
+ "(MenuBarHandle mbar) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"DuplicateMenuBar", (PyCFunction)Menu_DuplicateMenuBar, 1,
+ "(MenuBarHandle mbar) -> (MenuBarHandle outBar)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"DisposeMenuBar", (PyCFunction)Menu_DisposeMenuBar, 1,
+ "(MenuBarHandle mbar) -> None"},
+#endif
+ {"GetMenuHandle", (PyCFunction)Menu_GetMenuHandle, 1,
+ "(MenuID menuID) -> (MenuHandle _rv)"},
+ {"MacDeleteMenu", (PyCFunction)Menu_MacDeleteMenu, 1,
+ "(MenuID menuID) -> None"},
+ {"ClearMenuBar", (PyCFunction)Menu_ClearMenuBar, 1,
+ "() -> None"},
+ {"SetMenuFlashCount", (PyCFunction)Menu_SetMenuFlashCount, 1,
+ "(short count) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+ {"SetMenuFlash", (PyCFunction)Menu_SetMenuFlash, 1,
+ "(short count) -> None"},
+#endif
+ {"FlashMenuBar", (PyCFunction)Menu_FlashMenuBar, 1,
+ "(MenuID menuID) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+ {"SystemEdit", (PyCFunction)Menu_SystemEdit, 1,
+ "(short editCmd) -> (Boolean _rv)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"SystemMenu", (PyCFunction)Menu_SystemMenu, 1,
+ "(long menuResult) -> None"},
+#endif
+ {"IsMenuBarVisible", (PyCFunction)Menu_IsMenuBarVisible, 1,
+ "() -> (Boolean _rv)"},
+ {"ShowMenuBar", (PyCFunction)Menu_ShowMenuBar, 1,
+ "() -> None"},
+ {"HideMenuBar", (PyCFunction)Menu_HideMenuBar, 1,
+ "() -> None"},
+ {"DeleteMCEntries", (PyCFunction)Menu_DeleteMCEntries, 1,
+ "(MenuID menuID, short menuItem) -> None"},
+ {"InitContextualMenus", (PyCFunction)Menu_InitContextualMenus, 1,
+ "() -> None"},
+ {"IsShowContextualMenuClick", (PyCFunction)Menu_IsShowContextualMenuClick, 1,
+ "(EventRecord inEvent) -> (Boolean _rv)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"OpenDeskAcc", (PyCFunction)Menu_OpenDeskAcc, 1,
+ "(Str255 name) -> None"},
+#endif
+ {"as_Menu", (PyCFunction)Menu_as_Menu, 1,
+ "(Handle h) -> (MenuHandle _rv)"},
+ {"GetMenu", (PyCFunction)Menu_GetMenu, 1,
+ "(short resourceID) -> (MenuHandle _rv)"},
+ {"DeleteMenu", (PyCFunction)Menu_DeleteMenu, 1,
+ "(short menuID) -> None"},
+ {"DrawMenuBar", (PyCFunction)Menu_DrawMenuBar, 1,
+ "() -> None"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_Menu(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(MenuHandle, MenuObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(MenuHandle, MenuObj_Convert);
+
+
+ m = Py_InitModule("_Menu", Menu_methods);
+ d = PyModule_GetDict(m);
+ Menu_Error = PyMac_GetOSErrException();
+ if (Menu_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Menu_Error) != 0)
+ return;
+ Menu_Type.ob_type = &PyType_Type;
+ Py_INCREF(&Menu_Type);
+ if (PyDict_SetItemString(d, "MenuType", (PyObject *)&Menu_Type) != 0)
+ Py_FatalError("can't initialize MenuType");
+}
+
+/* ======================== End module _Menu ======================== */
+
--- /dev/null
+
+/* ========================== Module _Mlte ========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <MacTextEditor.h>
+#else
+#include <xxxx.h>
+#endif
+
+/* For now we declare them forward here. They'll go to mactoolbox later */
+staticforward PyObject *TXNObj_New(TXNObject);
+staticforward int TXNObj_Convert(PyObject *, TXNObject *);
+staticforward PyObject *TXNFontMenuObj_New(TXNFontMenuObject);
+staticforward int TXNFontMenuObj_Convert(PyObject *, TXNFontMenuObject *);
+
+// ADD declarations
+#ifdef NOTYET_USE_TOOLBOX_OBJECT_GLUE
+//extern PyObject *_CFTypeRefObj_New(CFTypeRef);
+//extern int _CFTypeRefObj_Convert(PyObject *, CFTypeRef *);
+
+//#define CFTypeRefObj_New _CFTypeRefObj_New
+//#define CFTypeRefObj_Convert _CFTypeRefObj_Convert
+#endif
+
+/*
+** Parse an optional fsspec
+*/
+static int
+OptFSSpecPtr_Convert(PyObject *v, FSSpec **p_itself)
+{
+ static FSSpec fss;
+ if (v == Py_None)
+ {
+ *p_itself = NULL;
+ return 1;
+ }
+ *p_itself = &fss;
+ return PyMac_GetFSSpec(v, *p_itself);
+}
+
+/*
+** Parse an optional rect
+*/
+static int
+OptRectPtr_Convert(PyObject *v, Rect **p_itself)
+{
+ static Rect r;
+
+ if (v == Py_None)
+ {
+ *p_itself = NULL;
+ return 1;
+ }
+ *p_itself = &r;
+ return PyMac_GetRect(v, *p_itself);
+}
+
+/*
+** Parse an optional GWorld
+*/
+static int
+OptGWorldObj_Convert(PyObject *v, GWorldPtr *p_itself)
+{
+ if (v == Py_None)
+ {
+ *p_itself = NULL;
+ return 1;
+ }
+ return GWorldObj_Convert(v, p_itself);
+}
+
+
+static PyObject *Mlte_Error;
+
+/* --------------------- Object type TXNObject ---------------------- */
+
+PyTypeObject TXNObject_Type;
+
+#define TXNObj_Check(x) ((x)->ob_type == &TXNObject_Type)
+
+typedef struct TXNObjectObject {
+ PyObject_HEAD
+ TXNObject ob_itself;
+} TXNObjectObject;
+
+PyObject *TXNObj_New(TXNObject itself)
+{
+ TXNObjectObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(TXNObjectObject, &TXNObject_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+TXNObj_Convert(PyObject *v, TXNObject *p_itself)
+{
+ if (!TXNObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "TXNObject required");
+ return 0;
+ }
+ *p_itself = ((TXNObjectObject *)v)->ob_itself;
+ return 1;
+}
+
+static void TXNObj_dealloc(TXNObjectObject *self)
+{
+ /* Cleanup of self->ob_itself goes here */
+ PyMem_DEL(self);
+}
+
+static PyObject *TXNObj_TXNDeleteObject(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyMac_PRECHECK(TXNDeleteObject);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TXNDeleteObject(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNResizeFrame(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt32 iWidth;
+ UInt32 iHeight;
+ TXNFrameID iTXNFrameID;
+ PyMac_PRECHECK(TXNResizeFrame);
+ if (!PyArg_ParseTuple(_args, "lll",
+ &iWidth,
+ &iHeight,
+ &iTXNFrameID))
+ return NULL;
+ TXNResizeFrame(_self->ob_itself,
+ iWidth,
+ iHeight,
+ iTXNFrameID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNSetFrameBounds(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 iTop;
+ SInt32 iLeft;
+ SInt32 iBottom;
+ SInt32 iRight;
+ TXNFrameID iTXNFrameID;
+ PyMac_PRECHECK(TXNSetFrameBounds);
+ if (!PyArg_ParseTuple(_args, "lllll",
+ &iTop,
+ &iLeft,
+ &iBottom,
+ &iRight,
+ &iTXNFrameID))
+ return NULL;
+ TXNSetFrameBounds(_self->ob_itself,
+ iTop,
+ iLeft,
+ iBottom,
+ iRight,
+ iTXNFrameID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNKeyDown(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ EventRecord iEvent;
+ PyMac_PRECHECK(TXNKeyDown);
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &iEvent))
+ return NULL;
+ TXNKeyDown(_self->ob_itself,
+ &iEvent);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNAdjustCursor(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle ioCursorRgn;
+ PyMac_PRECHECK(TXNAdjustCursor);
+ if (!PyArg_ParseTuple(_args, "O&",
+ OptResObj_Convert, &ioCursorRgn))
+ return NULL;
+ TXNAdjustCursor(_self->ob_itself,
+ ioCursorRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNClick(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ EventRecord iEvent;
+ PyMac_PRECHECK(TXNClick);
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &iEvent))
+ return NULL;
+ TXNClick(_self->ob_itself,
+ &iEvent);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_OSX
+
+static PyObject *TXNObj_TXNTSMCheck(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventRecord iEvent;
+ PyMac_PRECHECK(TXNTSMCheck);
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &iEvent))
+ return NULL;
+ _rv = TXNTSMCheck(_self->ob_itself,
+ &iEvent);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *TXNObj_TXNSelectAll(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyMac_PRECHECK(TXNSelectAll);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TXNSelectAll(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNFocus(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean iBecomingFocused;
+ PyMac_PRECHECK(TXNFocus);
+ if (!PyArg_ParseTuple(_args, "b",
+ &iBecomingFocused))
+ return NULL;
+ TXNFocus(_self->ob_itself,
+ iBecomingFocused);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNUpdate(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyMac_PRECHECK(TXNUpdate);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TXNUpdate(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNDraw(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GWorldPtr iDrawPort;
+ PyMac_PRECHECK(TXNDraw);
+ if (!PyArg_ParseTuple(_args, "O&",
+ OptGWorldObj_Convert, &iDrawPort))
+ return NULL;
+ TXNDraw(_self->ob_itself,
+ iDrawPort);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNForceUpdate(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyMac_PRECHECK(TXNForceUpdate);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TXNForceUpdate(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNGetSleepTicks(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt32 _rv;
+ PyMac_PRECHECK(TXNGetSleepTicks);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TXNGetSleepTicks(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNIdle(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyMac_PRECHECK(TXNIdle);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TXNIdle(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNGrowWindow(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ EventRecord iEvent;
+ PyMac_PRECHECK(TXNGrowWindow);
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &iEvent))
+ return NULL;
+ TXNGrowWindow(_self->ob_itself,
+ &iEvent);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNZoomWindow(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short iPart;
+ PyMac_PRECHECK(TXNZoomWindow);
+ if (!PyArg_ParseTuple(_args, "h",
+ &iPart))
+ return NULL;
+ TXNZoomWindow(_self->ob_itself,
+ iPart);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNCanUndo(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ TXNActionKey oTXNActionKey;
+ PyMac_PRECHECK(TXNCanUndo);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TXNCanUndo(_self->ob_itself,
+ &oTXNActionKey);
+ _res = Py_BuildValue("bl",
+ _rv,
+ oTXNActionKey);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNUndo(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyMac_PRECHECK(TXNUndo);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TXNUndo(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNCanRedo(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ TXNActionKey oTXNActionKey;
+ PyMac_PRECHECK(TXNCanRedo);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TXNCanRedo(_self->ob_itself,
+ &oTXNActionKey);
+ _res = Py_BuildValue("bl",
+ _rv,
+ oTXNActionKey);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNRedo(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyMac_PRECHECK(TXNRedo);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TXNRedo(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNCut(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ PyMac_PRECHECK(TXNCut);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = TXNCut(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNCopy(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ PyMac_PRECHECK(TXNCopy);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = TXNCopy(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNPaste(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ PyMac_PRECHECK(TXNPaste);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = TXNPaste(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNClear(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ PyMac_PRECHECK(TXNClear);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = TXNClear(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNGetSelection(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TXNOffset oStartOffset;
+ TXNOffset oEndOffset;
+ PyMac_PRECHECK(TXNGetSelection);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TXNGetSelection(_self->ob_itself,
+ &oStartOffset,
+ &oEndOffset);
+ _res = Py_BuildValue("ll",
+ oStartOffset,
+ oEndOffset);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNShowSelection(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean iShowEnd;
+ PyMac_PRECHECK(TXNShowSelection);
+ if (!PyArg_ParseTuple(_args, "b",
+ &iShowEnd))
+ return NULL;
+ TXNShowSelection(_self->ob_itself,
+ iShowEnd);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNIsSelectionEmpty(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ PyMac_PRECHECK(TXNIsSelectionEmpty);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TXNIsSelectionEmpty(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNSetSelection(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ TXNOffset iStartOffset;
+ TXNOffset iEndOffset;
+ PyMac_PRECHECK(TXNSetSelection);
+ if (!PyArg_ParseTuple(_args, "ll",
+ &iStartOffset,
+ &iEndOffset))
+ return NULL;
+ _err = TXNSetSelection(_self->ob_itself,
+ iStartOffset,
+ iEndOffset);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNCountRunsInRange(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ UInt32 iStartOffset;
+ UInt32 iEndOffset;
+ ItemCount oRunCount;
+ PyMac_PRECHECK(TXNCountRunsInRange);
+ if (!PyArg_ParseTuple(_args, "ll",
+ &iStartOffset,
+ &iEndOffset))
+ return NULL;
+ _err = TXNCountRunsInRange(_self->ob_itself,
+ iStartOffset,
+ iEndOffset,
+ &oRunCount);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ oRunCount);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNDataSize(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ByteCount _rv;
+ PyMac_PRECHECK(TXNDataSize);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TXNDataSize(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNGetData(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ TXNOffset iStartOffset;
+ TXNOffset iEndOffset;
+ Handle oDataHandle;
+ PyMac_PRECHECK(TXNGetData);
+ if (!PyArg_ParseTuple(_args, "ll",
+ &iStartOffset,
+ &iEndOffset))
+ return NULL;
+ _err = TXNGetData(_self->ob_itself,
+ iStartOffset,
+ iEndOffset,
+ &oDataHandle);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, oDataHandle);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNGetDataEncoded(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ TXNOffset iStartOffset;
+ TXNOffset iEndOffset;
+ Handle oDataHandle;
+ TXNDataType iEncoding;
+ PyMac_PRECHECK(TXNGetDataEncoded);
+ if (!PyArg_ParseTuple(_args, "llO&",
+ &iStartOffset,
+ &iEndOffset,
+ PyMac_GetOSType, &iEncoding))
+ return NULL;
+ _err = TXNGetDataEncoded(_self->ob_itself,
+ iStartOffset,
+ iEndOffset,
+ &oDataHandle,
+ iEncoding);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, oDataHandle);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNSetDataFromFile(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ SInt16 iFileRefNum;
+ OSType iFileType;
+ ByteCount iFileLength;
+ TXNOffset iStartOffset;
+ TXNOffset iEndOffset;
+ PyMac_PRECHECK(TXNSetDataFromFile);
+ if (!PyArg_ParseTuple(_args, "hO&lll",
+ &iFileRefNum,
+ PyMac_GetOSType, &iFileType,
+ &iFileLength,
+ &iStartOffset,
+ &iEndOffset))
+ return NULL;
+ _err = TXNSetDataFromFile(_self->ob_itself,
+ iFileRefNum,
+ iFileType,
+ iFileLength,
+ iStartOffset,
+ iEndOffset);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNSetData(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ TXNDataType iDataType;
+ void * *iDataPtr__in__;
+ ByteCount iDataPtr__len__;
+ int iDataPtr__in_len__;
+ TXNOffset iStartOffset;
+ TXNOffset iEndOffset;
+ PyMac_PRECHECK(TXNSetData);
+ if (!PyArg_ParseTuple(_args, "O&s#ll",
+ PyMac_GetOSType, &iDataType,
+ &iDataPtr__in__, &iDataPtr__in_len__,
+ &iStartOffset,
+ &iEndOffset))
+ return NULL;
+ iDataPtr__len__ = iDataPtr__in_len__;
+ _err = TXNSetData(_self->ob_itself,
+ iDataType,
+ iDataPtr__in__, iDataPtr__len__,
+ iStartOffset,
+ iEndOffset);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ iDataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNGetChangeCount(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ItemCount _rv;
+ PyMac_PRECHECK(TXNGetChangeCount);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TXNGetChangeCount(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNSave(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ OSType iType;
+ OSType iResType;
+ TXNPermanentTextEncodingType iPermanentEncoding;
+ FSSpec iFileSpecification;
+ SInt16 iDataReference;
+ SInt16 iResourceReference;
+ PyMac_PRECHECK(TXNSave);
+ if (!PyArg_ParseTuple(_args, "O&O&lO&hh",
+ PyMac_GetOSType, &iType,
+ PyMac_GetOSType, &iResType,
+ &iPermanentEncoding,
+ PyMac_GetFSSpec, &iFileSpecification,
+ &iDataReference,
+ &iResourceReference))
+ return NULL;
+ _err = TXNSave(_self->ob_itself,
+ iType,
+ iResType,
+ iPermanentEncoding,
+ &iFileSpecification,
+ iDataReference,
+ iResourceReference);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNRevert(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ PyMac_PRECHECK(TXNRevert);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = TXNRevert(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNPageSetup(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ PyMac_PRECHECK(TXNPageSetup);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = TXNPageSetup(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNPrint(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ PyMac_PRECHECK(TXNPrint);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = TXNPrint(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNGetViewRect(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect oViewRect;
+ PyMac_PRECHECK(TXNGetViewRect);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TXNGetViewRect(_self->ob_itself,
+ &oViewRect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &oViewRect);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNAttachObjectToWindow(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ GWorldPtr iWindow;
+ Boolean iIsActualWindow;
+ PyMac_PRECHECK(TXNAttachObjectToWindow);
+ if (!PyArg_ParseTuple(_args, "O&b",
+ GWorldObj_Convert, &iWindow,
+ &iIsActualWindow))
+ return NULL;
+ _err = TXNAttachObjectToWindow(_self->ob_itself,
+ iWindow,
+ iIsActualWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNIsObjectAttachedToWindow(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ PyMac_PRECHECK(TXNIsObjectAttachedToWindow);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TXNIsObjectAttachedToWindow(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *TXNObj_TXNDragTracker(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TXNFrameID iTXNFrameID;
+ DragTrackingMessage iMessage;
+ WindowPtr iWindow;
+ DragReference iDragReference;
+ Boolean iDifferentObjectSameWindow;
+ PyMac_PRECHECK(TXNDragTracker);
+ if (!PyArg_ParseTuple(_args, "lhO&O&b",
+ &iTXNFrameID,
+ &iMessage,
+ WinObj_Convert, &iWindow,
+ DragObj_Convert, &iDragReference,
+ &iDifferentObjectSameWindow))
+ return NULL;
+ _err = TXNDragTracker(_self->ob_itself,
+ iTXNFrameID,
+ iMessage,
+ iWindow,
+ iDragReference,
+ iDifferentObjectSameWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNDragReceiver(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TXNFrameID iTXNFrameID;
+ WindowPtr iWindow;
+ DragReference iDragReference;
+ Boolean iDifferentObjectSameWindow;
+ PyMac_PRECHECK(TXNDragReceiver);
+ if (!PyArg_ParseTuple(_args, "lO&O&b",
+ &iTXNFrameID,
+ WinObj_Convert, &iWindow,
+ DragObj_Convert, &iDragReference,
+ &iDifferentObjectSameWindow))
+ return NULL;
+ _err = TXNDragReceiver(_self->ob_itself,
+ iTXNFrameID,
+ iWindow,
+ iDragReference,
+ iDifferentObjectSameWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNActivate(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ TXNFrameID iTXNFrameID;
+ TXNScrollBarState iActiveState;
+ PyMac_PRECHECK(TXNActivate);
+ if (!PyArg_ParseTuple(_args, "ll",
+ &iTXNFrameID,
+ &iActiveState))
+ return NULL;
+ _err = TXNActivate(_self->ob_itself,
+ iTXNFrameID,
+ iActiveState);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNDoFontMenuSelection(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ TXNFontMenuObject iTXNFontMenuObject;
+ SInt16 iMenuID;
+ SInt16 iMenuItem;
+ PyMac_PRECHECK(TXNDoFontMenuSelection);
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ TXNFontMenuObj_Convert, &iTXNFontMenuObject,
+ &iMenuID,
+ &iMenuItem))
+ return NULL;
+ _err = TXNDoFontMenuSelection(_self->ob_itself,
+ iTXNFontMenuObject,
+ iMenuID,
+ iMenuItem);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TXNObj_TXNPrepareFontMenu(TXNObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ TXNFontMenuObject iTXNFontMenuObject;
+ PyMac_PRECHECK(TXNPrepareFontMenu);
+ if (!PyArg_ParseTuple(_args, "O&",
+ TXNFontMenuObj_Convert, &iTXNFontMenuObject))
+ return NULL;
+ _err = TXNPrepareFontMenu(_self->ob_itself,
+ iTXNFontMenuObject);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef TXNObj_methods[] = {
+ {"TXNDeleteObject", (PyCFunction)TXNObj_TXNDeleteObject, 1,
+ "() -> None"},
+ {"TXNResizeFrame", (PyCFunction)TXNObj_TXNResizeFrame, 1,
+ "(UInt32 iWidth, UInt32 iHeight, TXNFrameID iTXNFrameID) -> None"},
+ {"TXNSetFrameBounds", (PyCFunction)TXNObj_TXNSetFrameBounds, 1,
+ "(SInt32 iTop, SInt32 iLeft, SInt32 iBottom, SInt32 iRight, TXNFrameID iTXNFrameID) -> None"},
+ {"TXNKeyDown", (PyCFunction)TXNObj_TXNKeyDown, 1,
+ "(EventRecord iEvent) -> None"},
+ {"TXNAdjustCursor", (PyCFunction)TXNObj_TXNAdjustCursor, 1,
+ "(RgnHandle ioCursorRgn) -> None"},
+ {"TXNClick", (PyCFunction)TXNObj_TXNClick, 1,
+ "(EventRecord iEvent) -> None"},
+
+#if !TARGET_API_MAC_OSX
+ {"TXNTSMCheck", (PyCFunction)TXNObj_TXNTSMCheck, 1,
+ "(EventRecord iEvent) -> (Boolean _rv)"},
+#endif
+ {"TXNSelectAll", (PyCFunction)TXNObj_TXNSelectAll, 1,
+ "() -> None"},
+ {"TXNFocus", (PyCFunction)TXNObj_TXNFocus, 1,
+ "(Boolean iBecomingFocused) -> None"},
+ {"TXNUpdate", (PyCFunction)TXNObj_TXNUpdate, 1,
+ "() -> None"},
+ {"TXNDraw", (PyCFunction)TXNObj_TXNDraw, 1,
+ "(GWorldPtr iDrawPort) -> None"},
+ {"TXNForceUpdate", (PyCFunction)TXNObj_TXNForceUpdate, 1,
+ "() -> None"},
+ {"TXNGetSleepTicks", (PyCFunction)TXNObj_TXNGetSleepTicks, 1,
+ "() -> (UInt32 _rv)"},
+ {"TXNIdle", (PyCFunction)TXNObj_TXNIdle, 1,
+ "() -> None"},
+ {"TXNGrowWindow", (PyCFunction)TXNObj_TXNGrowWindow, 1,
+ "(EventRecord iEvent) -> None"},
+ {"TXNZoomWindow", (PyCFunction)TXNObj_TXNZoomWindow, 1,
+ "(short iPart) -> None"},
+ {"TXNCanUndo", (PyCFunction)TXNObj_TXNCanUndo, 1,
+ "() -> (Boolean _rv, TXNActionKey oTXNActionKey)"},
+ {"TXNUndo", (PyCFunction)TXNObj_TXNUndo, 1,
+ "() -> None"},
+ {"TXNCanRedo", (PyCFunction)TXNObj_TXNCanRedo, 1,
+ "() -> (Boolean _rv, TXNActionKey oTXNActionKey)"},
+ {"TXNRedo", (PyCFunction)TXNObj_TXNRedo, 1,
+ "() -> None"},
+ {"TXNCut", (PyCFunction)TXNObj_TXNCut, 1,
+ "() -> None"},
+ {"TXNCopy", (PyCFunction)TXNObj_TXNCopy, 1,
+ "() -> None"},
+ {"TXNPaste", (PyCFunction)TXNObj_TXNPaste, 1,
+ "() -> None"},
+ {"TXNClear", (PyCFunction)TXNObj_TXNClear, 1,
+ "() -> None"},
+ {"TXNGetSelection", (PyCFunction)TXNObj_TXNGetSelection, 1,
+ "() -> (TXNOffset oStartOffset, TXNOffset oEndOffset)"},
+ {"TXNShowSelection", (PyCFunction)TXNObj_TXNShowSelection, 1,
+ "(Boolean iShowEnd) -> None"},
+ {"TXNIsSelectionEmpty", (PyCFunction)TXNObj_TXNIsSelectionEmpty, 1,
+ "() -> (Boolean _rv)"},
+ {"TXNSetSelection", (PyCFunction)TXNObj_TXNSetSelection, 1,
+ "(TXNOffset iStartOffset, TXNOffset iEndOffset) -> None"},
+ {"TXNCountRunsInRange", (PyCFunction)TXNObj_TXNCountRunsInRange, 1,
+ "(UInt32 iStartOffset, UInt32 iEndOffset) -> (ItemCount oRunCount)"},
+ {"TXNDataSize", (PyCFunction)TXNObj_TXNDataSize, 1,
+ "() -> (ByteCount _rv)"},
+ {"TXNGetData", (PyCFunction)TXNObj_TXNGetData, 1,
+ "(TXNOffset iStartOffset, TXNOffset iEndOffset) -> (Handle oDataHandle)"},
+ {"TXNGetDataEncoded", (PyCFunction)TXNObj_TXNGetDataEncoded, 1,
+ "(TXNOffset iStartOffset, TXNOffset iEndOffset, TXNDataType iEncoding) -> (Handle oDataHandle)"},
+ {"TXNSetDataFromFile", (PyCFunction)TXNObj_TXNSetDataFromFile, 1,
+ "(SInt16 iFileRefNum, OSType iFileType, ByteCount iFileLength, TXNOffset iStartOffset, TXNOffset iEndOffset) -> None"},
+ {"TXNSetData", (PyCFunction)TXNObj_TXNSetData, 1,
+ "(TXNDataType iDataType, Buffer iDataPtr, TXNOffset iStartOffset, TXNOffset iEndOffset) -> None"},
+ {"TXNGetChangeCount", (PyCFunction)TXNObj_TXNGetChangeCount, 1,
+ "() -> (ItemCount _rv)"},
+ {"TXNSave", (PyCFunction)TXNObj_TXNSave, 1,
+ "(OSType iType, OSType iResType, TXNPermanentTextEncodingType iPermanentEncoding, FSSpec iFileSpecification, SInt16 iDataReference, SInt16 iResourceReference) -> None"},
+ {"TXNRevert", (PyCFunction)TXNObj_TXNRevert, 1,
+ "() -> None"},
+ {"TXNPageSetup", (PyCFunction)TXNObj_TXNPageSetup, 1,
+ "() -> None"},
+ {"TXNPrint", (PyCFunction)TXNObj_TXNPrint, 1,
+ "() -> None"},
+ {"TXNGetViewRect", (PyCFunction)TXNObj_TXNGetViewRect, 1,
+ "() -> (Rect oViewRect)"},
+ {"TXNAttachObjectToWindow", (PyCFunction)TXNObj_TXNAttachObjectToWindow, 1,
+ "(GWorldPtr iWindow, Boolean iIsActualWindow) -> None"},
+ {"TXNIsObjectAttachedToWindow", (PyCFunction)TXNObj_TXNIsObjectAttachedToWindow, 1,
+ "() -> (Boolean _rv)"},
+ {"TXNDragTracker", (PyCFunction)TXNObj_TXNDragTracker, 1,
+ "(TXNFrameID iTXNFrameID, DragTrackingMessage iMessage, WindowPtr iWindow, DragReference iDragReference, Boolean iDifferentObjectSameWindow) -> None"},
+ {"TXNDragReceiver", (PyCFunction)TXNObj_TXNDragReceiver, 1,
+ "(TXNFrameID iTXNFrameID, WindowPtr iWindow, DragReference iDragReference, Boolean iDifferentObjectSameWindow) -> None"},
+ {"TXNActivate", (PyCFunction)TXNObj_TXNActivate, 1,
+ "(TXNFrameID iTXNFrameID, TXNScrollBarState iActiveState) -> None"},
+ {"TXNDoFontMenuSelection", (PyCFunction)TXNObj_TXNDoFontMenuSelection, 1,
+ "(TXNFontMenuObject iTXNFontMenuObject, SInt16 iMenuID, SInt16 iMenuItem) -> None"},
+ {"TXNPrepareFontMenu", (PyCFunction)TXNObj_TXNPrepareFontMenu, 1,
+ "(TXNFontMenuObject iTXNFontMenuObject) -> None"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain TXNObj_chain = { TXNObj_methods, NULL };
+
+static PyObject *TXNObj_getattr(TXNObjectObject *self, char *name)
+{
+ return Py_FindMethodInChain(&TXNObj_chain, (PyObject *)self, name);
+}
+
+#define TXNObj_setattr NULL
+
+#define TXNObj_compare NULL
+
+#define TXNObj_repr NULL
+
+#define TXNObj_hash NULL
+
+PyTypeObject TXNObject_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "TXNObject", /*tp_name*/
+ sizeof(TXNObjectObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) TXNObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) TXNObj_getattr, /*tp_getattr*/
+ (setattrfunc) TXNObj_setattr, /*tp_setattr*/
+ (cmpfunc) TXNObj_compare, /*tp_compare*/
+ (reprfunc) TXNObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) TXNObj_hash, /*tp_hash*/
+};
+
+/* ------------------- End object type TXNObject -------------------- */
+
+
+/* ----------------- Object type TXNFontMenuObject ------------------ */
+
+PyTypeObject TXNFontMenuObject_Type;
+
+#define TXNFontMenuObj_Check(x) ((x)->ob_type == &TXNFontMenuObject_Type)
+
+typedef struct TXNFontMenuObjectObject {
+ PyObject_HEAD
+ TXNFontMenuObject ob_itself;
+} TXNFontMenuObjectObject;
+
+PyObject *TXNFontMenuObj_New(TXNFontMenuObject itself)
+{
+ TXNFontMenuObjectObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(TXNFontMenuObjectObject, &TXNFontMenuObject_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+TXNFontMenuObj_Convert(PyObject *v, TXNFontMenuObject *p_itself)
+{
+ if (!TXNFontMenuObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "TXNFontMenuObject required");
+ return 0;
+ }
+ *p_itself = ((TXNFontMenuObjectObject *)v)->ob_itself;
+ return 1;
+}
+
+static void TXNFontMenuObj_dealloc(TXNFontMenuObjectObject *self)
+{
+ /* Cleanup of self->ob_itself goes here */
+ PyMem_DEL(self);
+}
+
+static PyObject *TXNFontMenuObj_TXNGetFontMenuHandle(TXNFontMenuObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuHandle oFontMenuHandle;
+ PyMac_PRECHECK(TXNGetFontMenuHandle);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = TXNGetFontMenuHandle(_self->ob_itself,
+ &oFontMenuHandle);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, oFontMenuHandle);
+ return _res;
+}
+
+static PyObject *TXNFontMenuObj_TXNDisposeFontMenuObject(TXNFontMenuObjectObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ PyMac_PRECHECK(TXNDisposeFontMenuObject);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = TXNDisposeFontMenuObject(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef TXNFontMenuObj_methods[] = {
+ {"TXNGetFontMenuHandle", (PyCFunction)TXNFontMenuObj_TXNGetFontMenuHandle, 1,
+ "() -> (MenuHandle oFontMenuHandle)"},
+ {"TXNDisposeFontMenuObject", (PyCFunction)TXNFontMenuObj_TXNDisposeFontMenuObject, 1,
+ "() -> None"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain TXNFontMenuObj_chain = { TXNFontMenuObj_methods, NULL };
+
+static PyObject *TXNFontMenuObj_getattr(TXNFontMenuObjectObject *self, char *name)
+{
+ return Py_FindMethodInChain(&TXNFontMenuObj_chain, (PyObject *)self, name);
+}
+
+#define TXNFontMenuObj_setattr NULL
+
+#define TXNFontMenuObj_compare NULL
+
+#define TXNFontMenuObj_repr NULL
+
+#define TXNFontMenuObj_hash NULL
+
+PyTypeObject TXNFontMenuObject_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "TXNFontMenuObject", /*tp_name*/
+ sizeof(TXNFontMenuObjectObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) TXNFontMenuObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) TXNFontMenuObj_getattr, /*tp_getattr*/
+ (setattrfunc) TXNFontMenuObj_setattr, /*tp_setattr*/
+ (cmpfunc) TXNFontMenuObj_compare, /*tp_compare*/
+ (reprfunc) TXNFontMenuObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) TXNFontMenuObj_hash, /*tp_hash*/
+};
+
+/* --------------- End object type TXNFontMenuObject ---------------- */
+
+
+static PyObject *Mlte_TXNNewObject(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ FSSpec * iFileSpec;
+ WindowPtr iWindow;
+ Rect * iFrame;
+ TXNFrameOptions iFrameOptions;
+ TXNFrameType iFrameType;
+ TXNFileType iFileType;
+ TXNPermanentTextEncodingType iPermanentEncoding;
+ TXNObject oTXNObject;
+ TXNFrameID oTXNFrameID;
+ PyMac_PRECHECK(TXNNewObject);
+ if (!PyArg_ParseTuple(_args, "O&O&O&llO&l",
+ OptFSSpecPtr_Convert, &iFileSpec,
+ WinObj_Convert, &iWindow,
+ OptRectPtr_Convert, &iFrame,
+ &iFrameOptions,
+ &iFrameType,
+ PyMac_GetOSType, &iFileType,
+ &iPermanentEncoding))
+ return NULL;
+ _err = TXNNewObject(iFileSpec,
+ iWindow,
+ iFrame,
+ iFrameOptions,
+ iFrameType,
+ iFileType,
+ iPermanentEncoding,
+ &oTXNObject,
+ &oTXNFrameID,
+ (TXNObjectRefcon)0);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&l",
+ TXNObj_New, oTXNObject,
+ oTXNFrameID);
+ return _res;
+}
+
+static PyObject *Mlte_TXNTerminateTextension(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PyMac_PRECHECK(TXNTerminateTextension);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TXNTerminateTextension();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Mlte_TXNIsScrapPastable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ PyMac_PRECHECK(TXNIsScrapPastable);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TXNIsScrapPastable();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Mlte_TXNConvertToPublicScrap(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ PyMac_PRECHECK(TXNConvertToPublicScrap);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = TXNConvertToPublicScrap();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Mlte_TXNConvertFromPublicScrap(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ PyMac_PRECHECK(TXNConvertFromPublicScrap);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = TXNConvertFromPublicScrap();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Mlte_TXNNewFontMenuObject(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuHandle iFontMenuHandle;
+ SInt16 iMenuID;
+ SInt16 iStartHierMenuID;
+ TXNFontMenuObject oTXNFontMenuObject;
+ PyMac_PRECHECK(TXNNewFontMenuObject);
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ MenuObj_Convert, &iFontMenuHandle,
+ &iMenuID,
+ &iStartHierMenuID))
+ return NULL;
+ _err = TXNNewFontMenuObject(iFontMenuHandle,
+ iMenuID,
+ iStartHierMenuID,
+ &oTXNFontMenuObject);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ TXNFontMenuObj_New, oTXNFontMenuObject);
+ return _res;
+}
+
+static PyObject *Mlte_TXNVersionInformation(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TXNVersionValue _rv;
+ TXNFeatureBits oFeatureFlags;
+ PyMac_PRECHECK(TXNVersionInformation);
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TXNVersionInformation(&oFeatureFlags);
+ _res = Py_BuildValue("ll",
+ _rv,
+ oFeatureFlags);
+ return _res;
+}
+
+static PyObject *Mlte_TXNInitTextension(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ OSStatus _err;
+ TXNMacOSPreferredFontDescription * iDefaultFonts = NULL;
+ ItemCount iCountDefaultFonts = 0;
+ TXNInitOptions iUsageFlags;
+ PyMac_PRECHECK(TXNInitTextension);
+ if (!PyArg_ParseTuple(_args, "l", &iUsageFlags))
+ return NULL;
+ _err = TXNInitTextension(iDefaultFonts,
+ iCountDefaultFonts,
+ iUsageFlags);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+
+}
+
+static PyMethodDef Mlte_methods[] = {
+ {"TXNNewObject", (PyCFunction)Mlte_TXNNewObject, 1,
+ "(FSSpec * iFileSpec, WindowPtr iWindow, Rect * iFrame, TXNFrameOptions iFrameOptions, TXNFrameType iFrameType, TXNFileType iFileType, TXNPermanentTextEncodingType iPermanentEncoding) -> (TXNObject oTXNObject, TXNFrameID oTXNFrameID)"},
+ {"TXNTerminateTextension", (PyCFunction)Mlte_TXNTerminateTextension, 1,
+ "() -> None"},
+ {"TXNIsScrapPastable", (PyCFunction)Mlte_TXNIsScrapPastable, 1,
+ "() -> (Boolean _rv)"},
+ {"TXNConvertToPublicScrap", (PyCFunction)Mlte_TXNConvertToPublicScrap, 1,
+ "() -> None"},
+ {"TXNConvertFromPublicScrap", (PyCFunction)Mlte_TXNConvertFromPublicScrap, 1,
+ "() -> None"},
+ {"TXNNewFontMenuObject", (PyCFunction)Mlte_TXNNewFontMenuObject, 1,
+ "(MenuHandle iFontMenuHandle, SInt16 iMenuID, SInt16 iStartHierMenuID) -> (TXNFontMenuObject oTXNFontMenuObject)"},
+ {"TXNVersionInformation", (PyCFunction)Mlte_TXNVersionInformation, 1,
+ "() -> (TXNVersionValue _rv, TXNFeatureBits oFeatureFlags)"},
+ {"TXNInitTextension", (PyCFunction)Mlte_TXNInitTextension, 1,
+ "(TXNInitOptions) -> None"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_Mlte(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ // PyMac_INIT_TOOLBOX_OBJECT_NEW(xxxx);
+
+
+ m = Py_InitModule("_Mlte", Mlte_methods);
+ d = PyModule_GetDict(m);
+ Mlte_Error = PyMac_GetOSErrException();
+ if (Mlte_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Mlte_Error) != 0)
+ return;
+ TXNObject_Type.ob_type = &PyType_Type;
+ Py_INCREF(&TXNObject_Type);
+ if (PyDict_SetItemString(d, "TXNObjectType", (PyObject *)&TXNObject_Type) != 0)
+ Py_FatalError("can't initialize TXNObjectType");
+ TXNFontMenuObject_Type.ob_type = &PyType_Type;
+ Py_INCREF(&TXNFontMenuObject_Type);
+ if (PyDict_SetItemString(d, "TXNFontMenuObjectType", (PyObject *)&TXNFontMenuObject_Type) != 0)
+ Py_FatalError("can't initialize TXNFontMenuObjectType");
+}
+
+/* ======================== End module _Mlte ======================== */
+
--- /dev/null
+
+/* =========================== Module _Qd =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <QuickDraw.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+extern PyObject *_GrafObj_New(GrafPtr);
+extern int _GrafObj_Convert(PyObject *, GrafPtr *);
+extern PyObject *_BMObj_New(BitMapPtr);
+extern int _BMObj_Convert(PyObject *, BitMapPtr *);
+extern PyObject *_QdRGB_New(RGBColorPtr);
+extern int _QdRGB_Convert(PyObject *, RGBColorPtr);
+
+#define GrafObj_New _GrafObj_New
+#define GrafObj_Convert _GrafObj_Convert
+#define BMObj_New _BMObj_New
+#define BMObj_Convert _BMObj_Convert
+#define QdRGB_New _QdRGB_New
+#define QdRGB_Convert _QdRGB_Convert
+#endif
+
+#if !ACCESSOR_CALLS_ARE_FUNCTIONS
+#define GetPortBitMapForCopyBits(port) ((const struct BitMap *)&((GrafPort *)(port))->portBits)
+#define GetPortPixMap(port) (((CGrafPtr)(port))->portPixMap)
+#define GetPortBounds(port, bounds) (*(bounds) = (port)->portRect, (bounds))
+#define GetPortForeColor(port, color) (*(color) = (port)->rgbFgColor, (color))
+#define GetPortBackColor(port, color) (*(color) = (port)->rgbBkColor, (color))
+#define GetPortOpColor(port, color) (*(color) = (*(GVarHandle)((port)->grafVars))->rgbOpColor, (color))
+#define GetPortHiliteColor(port, color) (*(color) = (*(GVarHandle)((port)->grafVars))->rgbHiliteColor, (color))
+#define GetPortTextFont(port) ((port)->txFont)
+#define GetPortTextFace(port) ((port)->txFace)
+#define GetPortTextMode(port) ((port)->txMode)
+#define GetPortTextSize(port) ((port)->txSize)
+#define GetPortChExtra(port) ((port)->chExtra)
+#define GetPortFracHPenLocation(port) ((port)->pnLocHFrac)
+#define GetPortSpExtra(port) ((port)->spExtra)
+#define GetPortPenVisibility(port) ((port)->pnVis)
+#define GetPortVisibleRegion(port, rgn) ((rgn) = (port)->visRgn, (rgn))
+#define GetPortClipRegion(port, rgn) ((rgn) = (port)->clipRgn, (rgn))
+#define GetPortBackPixPat(port, pat) ((pat) = (port)->bkPixPat, (pat))
+#define GetPortPenPixPat(port, pat) ((pat) = (port)->pnPixPat, (pat))
+#define GetPortFillPixPat(port, pat) ((pat) = (port)->fillPixPat, (pat))
+#define GetPortPenSize(port, pensize) (*(pensize) = (port)->pnSize, (pensize))
+#define GetPortPenMode(port) ((port)->pnMode)
+#define GetPortPenLocation(port, location) ((*location) = (port)->pnLoc, (location))
+#define IsPortRegionBeingDefined(port) (!!((port)->rgnSave))
+#define IsPortPictureBeingDefined(port) (!!((port)->picSave))
+/* #define IsPortOffscreen(port) */
+/* #define IsPortColor(port) */
+
+#define SetPortBounds(port, bounds) ((port)->portRect = *(bounds))
+#define SetPortOpColor(port, color) ((*(GVarHandle)((port)->grafVars))->rgbOpColor = *(color))
+#define SetPortVisibleRegion(port, rgn) ((port)->visRgn = (rgn))
+#define SetPortClipRegion(port, rgn) ((port)->clipRgn = (rgn))
+#define SetPortBackPixPat(port, pat) ((port)->bkPixPat = (pat))
+#define SetPortPenPixPat(port, pat) ((port)->pnPixPat = (pat))
+#define SetPortFillPixPat(port, pat) ((port)->fillPixPat = (pat))
+#define SetPortPenSize(port, pensize) ((port)->pnSize = (pensize))
+#define SetPortPenMode(port, mode) ((port)->pnMode = (mode))
+#define SetPortFracHPenLocation(port, frac) ((port)->pnLocHFrac = (frac))
+
+/* On pixmaps */
+#define GetPixBounds(pixmap, rect) (*(rect) = (*(pixmap))->bounds, (rect))
+#define GetPixDepth(pixmap) ((*(pixmap))->pixelSize)
+
+/* On regions */
+#define GetRegionBounds(rgn, rect) (*(rect) = (*(rgn))->rgnBBox, (rect))
+
+/* On QD Globals */
+#define GetQDGlobalsRandomSeed() (qd.randSeed)
+#define GetQDGlobalsScreenBits(bits) (*(bits) = qd.screenBits, (bits))
+#define GetQDGlobalsArrow(crsr) (*(crsr) = qd.arrow, (crsr))
+#define GetQDGlobalsDarkGray(pat) (*(pat) = qd.dkGray, (pat))
+#define GetQDGlobalsLightGray(pat) (*(pat) = qd.ltGray, (pat))
+#define GetQDGlobalsGray(pat) (*(pat) = qd.gray, (pat))
+#define GetQDGlobalsBlack(pat) (*(pat) = qd.black, (pat))
+#define GetQDGlobalsWhite(pat) (*(pat) = qd.white, (pat))
+#define GetQDGlobalsThePort() ((CGrafPtr)qd.thePort)
+
+#define SetQDGlobalsRandomSeed(seed) (qd.randSeed = (seed))
+#define SetQDGlobalsArrow(crsr) (qd.arrow = *(crsr))
+
+#endif /* ACCESSOR_CALLS_ARE_FUNCTIONS */
+
+#if !TARGET_API_MAC_CARBON
+#define QDFlushPortBuffer(port, rgn) /* pass */
+#define QDIsPortBufferDirty(port) 0
+#define QDIsPortBuffered(port) 0
+#endif /* !TARGET_API_MAC_CARBON */
+
+staticforward PyObject *BMObj_NewCopied(BitMapPtr);
+
+/*
+** Parse/generate RGB records
+*/
+PyObject *QdRGB_New(RGBColorPtr itself)
+{
+
+ return Py_BuildValue("lll", (long)itself->red, (long)itself->green, (long)itself->blue);
+}
+
+QdRGB_Convert(PyObject *v, RGBColorPtr p_itself)
+{
+ long red, green, blue;
+
+ if( !PyArg_ParseTuple(v, "lll", &red, &green, &blue) )
+ return 0;
+ p_itself->red = (unsigned short)red;
+ p_itself->green = (unsigned short)green;
+ p_itself->blue = (unsigned short)blue;
+ return 1;
+}
+
+/*
+** Generate FontInfo records
+*/
+static
+PyObject *QdFI_New(FontInfo *itself)
+{
+
+ return Py_BuildValue("hhhh", itself->ascent, itself->descent,
+ itself->widMax, itself->leading);
+}
+
+static PyObject *Qd_Error;
+
+/* ---------------------- Object type GrafPort ---------------------- */
+
+PyTypeObject GrafPort_Type;
+
+#define GrafObj_Check(x) ((x)->ob_type == &GrafPort_Type)
+
+typedef struct GrafPortObject {
+ PyObject_HEAD
+ GrafPtr ob_itself;
+} GrafPortObject;
+
+PyObject *GrafObj_New(GrafPtr itself)
+{
+ GrafPortObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(GrafPortObject, &GrafPort_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+GrafObj_Convert(PyObject *v, GrafPtr *p_itself)
+{
+#if 1
+ {
+ WindowRef win;
+ if (WinObj_Convert(v, &win) && v) {
+ *p_itself = (GrafPtr)GetWindowPort(win);
+ return 1;
+ }
+ PyErr_Clear();
+ }
+#else
+ if (DlgObj_Check(v)) {
+ DialogRef dlg = (DialogRef)((GrafPortObject *)v)->ob_itself;
+ *p_itself = (GrafPtr)GetWindowPort(GetDialogWindow(dlg));
+ return 1;
+ }
+ if (WinObj_Check(v)) {
+ WindowRef win = (WindowRef)((GrafPortObject *)v)->ob_itself;
+ *p_itself = (GrafPtr)GetWindowPort(win);
+ return 1;
+ }
+#endif
+ if (!GrafObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "GrafPort required");
+ return 0;
+ }
+ *p_itself = ((GrafPortObject *)v)->ob_itself;
+ return 1;
+}
+
+static void GrafObj_dealloc(GrafPortObject *self)
+{
+ /* Cleanup of self->ob_itself goes here */
+ PyMem_DEL(self);
+}
+
+static PyMethodDef GrafObj_methods[] = {
+ {NULL, NULL, 0}
+};
+
+PyMethodChain GrafObj_chain = { GrafObj_methods, NULL };
+
+static PyObject *GrafObj_getattr(GrafPortObject *self, char *name)
+{
+#if !ACCESSOR_CALLS_ARE_FUNCTIONS
+
+ { CGrafPtr itself_color = (CGrafPtr)self->ob_itself;
+
+ if ( strcmp(name, "data") == 0 )
+ return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(GrafPort));
+
+ if ( (itself_color->portVersion&0xc000) == 0xc000 ) {
+ /* Color-only attributes */
+
+ if ( strcmp(name, "portBits") == 0 )
+ /* XXXX Do we need HLock() stuff here?? */
+ return BMObj_New((BitMapPtr)*itself_color->portPixMap);
+ if ( strcmp(name, "grafVars") == 0 )
+ return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->visRgn);
+ if ( strcmp(name, "chExtra") == 0 )
+ return Py_BuildValue("h", itself_color->chExtra);
+ if ( strcmp(name, "pnLocHFrac") == 0 )
+ return Py_BuildValue("h", itself_color->pnLocHFrac);
+ if ( strcmp(name, "bkPixPat") == 0 )
+ return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->bkPixPat);
+ if ( strcmp(name, "rgbFgColor") == 0 )
+ return Py_BuildValue("O&", QdRGB_New, &itself_color->rgbFgColor);
+ if ( strcmp(name, "rgbBkColor") == 0 )
+ return Py_BuildValue("O&", QdRGB_New, &itself_color->rgbBkColor);
+ if ( strcmp(name, "pnPixPat") == 0 )
+ return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->pnPixPat);
+ if ( strcmp(name, "fillPixPat") == 0 )
+ return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->fillPixPat);
+ } else {
+ /* Mono-only attributes */
+ if ( strcmp(name, "portBits") == 0 )
+ return BMObj_New(&self->ob_itself->portBits);
+ if ( strcmp(name, "bkPat") == 0 )
+ return Py_BuildValue("s#", (char *)&self->ob_itself->bkPat, sizeof(Pattern));
+ if ( strcmp(name, "fillPat") == 0 )
+ return Py_BuildValue("s#", (char *)&self->ob_itself->fillPat, sizeof(Pattern));
+ if ( strcmp(name, "pnPat") == 0 )
+ return Py_BuildValue("s#", (char *)&self->ob_itself->pnPat, sizeof(Pattern));
+ }
+ /*
+ ** Accessible for both color/mono windows.
+ ** portVersion is really color-only, but we put it here
+ ** for convenience
+ */
+ if ( strcmp(name, "portVersion") == 0 )
+ return Py_BuildValue("h", itself_color->portVersion);
+ if ( strcmp(name, "device") == 0 )
+ return PyInt_FromLong((long)self->ob_itself->device);
+ if ( strcmp(name, "portRect") == 0 )
+ return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->portRect);
+ if ( strcmp(name, "visRgn") == 0 )
+ return Py_BuildValue("O&", ResObj_New, (Handle)self->ob_itself->visRgn);
+ if ( strcmp(name, "clipRgn") == 0 )
+ return Py_BuildValue("O&", ResObj_New, (Handle)self->ob_itself->clipRgn);
+ if ( strcmp(name, "pnLoc") == 0 )
+ return Py_BuildValue("O&", PyMac_BuildPoint, self->ob_itself->pnLoc);
+ if ( strcmp(name, "pnSize") == 0 )
+ return Py_BuildValue("O&", PyMac_BuildPoint, self->ob_itself->pnSize);
+ if ( strcmp(name, "pnMode") == 0 )
+ return Py_BuildValue("h", self->ob_itself->pnMode);
+ if ( strcmp(name, "pnVis") == 0 )
+ return Py_BuildValue("h", self->ob_itself->pnVis);
+ if ( strcmp(name, "txFont") == 0 )
+ return Py_BuildValue("h", self->ob_itself->txFont);
+ if ( strcmp(name, "txFace") == 0 )
+ return Py_BuildValue("h", (short)self->ob_itself->txFace);
+ if ( strcmp(name, "txMode") == 0 )
+ return Py_BuildValue("h", self->ob_itself->txMode);
+ if ( strcmp(name, "txSize") == 0 )
+ return Py_BuildValue("h", self->ob_itself->txSize);
+ if ( strcmp(name, "spExtra") == 0 )
+ return Py_BuildValue("O&", PyMac_BuildFixed, self->ob_itself->spExtra);
+ /* XXXX Add more, as needed */
+ /* This one is so we can compare grafports: */
+ if ( strcmp(name, "_id") == 0 )
+ return Py_BuildValue("l", (long)self->ob_itself);
+ }
+#else
+
+ { CGrafPtr itself_color = (CGrafPtr)self->ob_itself;
+ if ( strcmp(name, "portBits") == 0 )
+ return BMObj_New((BitMapPtr)GetPortBitMapForCopyBits(itself_color));
+ if ( strcmp(name, "chExtra") == 0 )
+ return Py_BuildValue("h", GetPortChExtra(itself_color));
+ if ( strcmp(name, "pnLocHFrac") == 0 )
+ return Py_BuildValue("h", GetPortFracHPenLocation(itself_color));
+ if ( strcmp(name, "bkPixPat") == 0 ) {
+ PixPatHandle h=0;
+ return Py_BuildValue("O&", ResObj_New, (Handle)GetPortBackPixPat(itself_color, h));
+ }
+ if ( strcmp(name, "rgbFgColor") == 0 ) {
+ RGBColor c;
+ return Py_BuildValue("O&", QdRGB_New, GetPortForeColor(itself_color, &c));
+ }
+ if ( strcmp(name, "rgbBkColor") == 0 ) {
+ RGBColor c;
+ return Py_BuildValue("O&", QdRGB_New, GetPortBackColor(itself_color, &c));
+ }
+ if ( strcmp(name, "pnPixPat") == 0 ) {
+ PixPatHandle h=NewPixPat(); /* XXXX wrong dispose routine */
+
+ return Py_BuildValue("O&", ResObj_New, (Handle)GetPortPenPixPat(itself_color, h));
+ }
+ if ( strcmp(name, "fillPixPat") == 0 ) {
+ PixPatHandle h=NewPixPat(); /* XXXX wrong dispose routine */
+ return Py_BuildValue("O&", ResObj_New, (Handle)GetPortFillPixPat(itself_color, h));
+ }
+ if ( strcmp(name, "portRect") == 0 ) {
+ Rect r;
+ return Py_BuildValue("O&", PyMac_BuildRect, GetPortBounds(itself_color, &r));
+ }
+ if ( strcmp(name, "visRgn") == 0 ) {
+ RgnHandle h=NewRgn(); /* XXXX wrong dispose routine */
+ return Py_BuildValue("O&", ResObj_New, (Handle)GetPortVisibleRegion(itself_color, h));
+ }
+ if ( strcmp(name, "clipRgn") == 0 ) {
+ RgnHandle h=NewRgn(); /* XXXX wrong dispose routine */
+ return Py_BuildValue("O&", ResObj_New, (Handle)GetPortClipRegion(itself_color, h));
+ }
+ if ( strcmp(name, "pnLoc") == 0 ) {
+ Point p;
+ return Py_BuildValue("O&", PyMac_BuildPoint, *GetPortPenLocation(itself_color, &p));
+ }
+ if ( strcmp(name, "pnSize") == 0 ) {
+ Point p;
+ return Py_BuildValue("O&", PyMac_BuildPoint, *GetPortPenSize(itself_color, &p));
+ }
+ if ( strcmp(name, "pnMode") == 0 )
+ return Py_BuildValue("h", GetPortPenMode(itself_color));
+ if ( strcmp(name, "pnVis") == 0 )
+ return Py_BuildValue("h", GetPortPenVisibility(itself_color));
+ if ( strcmp(name, "txFont") == 0 )
+ return Py_BuildValue("h", GetPortTextFont(itself_color));
+ if ( strcmp(name, "txFace") == 0 )
+ return Py_BuildValue("h", (short)GetPortTextFace(itself_color));
+ if ( strcmp(name, "txMode") == 0 )
+ return Py_BuildValue("h", GetPortTextMode(itself_color));
+ if ( strcmp(name, "txSize") == 0 )
+ return Py_BuildValue("h", GetPortTextSize(itself_color));
+ if ( strcmp(name, "spExtra") == 0 )
+ return Py_BuildValue("O&", PyMac_BuildFixed, GetPortSpExtra(itself_color));
+ /* XXXX Add more, as needed */
+ /* This one is so we can compare grafports: */
+ if ( strcmp(name, "_id") == 0 )
+ return Py_BuildValue("l", (long)self->ob_itself);
+ }
+#endif
+ return Py_FindMethodInChain(&GrafObj_chain, (PyObject *)self, name);
+}
+
+#define GrafObj_setattr NULL
+
+#define GrafObj_compare NULL
+
+#define GrafObj_repr NULL
+
+#define GrafObj_hash NULL
+
+PyTypeObject GrafPort_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "GrafPort", /*tp_name*/
+ sizeof(GrafPortObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) GrafObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) GrafObj_getattr, /*tp_getattr*/
+ (setattrfunc) GrafObj_setattr, /*tp_setattr*/
+ (cmpfunc) GrafObj_compare, /*tp_compare*/
+ (reprfunc) GrafObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) GrafObj_hash, /*tp_hash*/
+};
+
+/* -------------------- End object type GrafPort -------------------- */
+
+
+/* ----------------------- Object type BitMap ----------------------- */
+
+PyTypeObject BitMap_Type;
+
+#define BMObj_Check(x) ((x)->ob_type == &BitMap_Type)
+
+typedef struct BitMapObject {
+ PyObject_HEAD
+ BitMapPtr ob_itself;
+ PyObject *referred_object;
+ BitMap *referred_bitmap;
+} BitMapObject;
+
+PyObject *BMObj_New(BitMapPtr itself)
+{
+ BitMapObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(BitMapObject, &BitMap_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->referred_object = NULL;
+ it->referred_bitmap = NULL;
+ return (PyObject *)it;
+}
+BMObj_Convert(PyObject *v, BitMapPtr *p_itself)
+{
+ if (!BMObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "BitMap required");
+ return 0;
+ }
+ *p_itself = ((BitMapObject *)v)->ob_itself;
+ return 1;
+}
+
+static void BMObj_dealloc(BitMapObject *self)
+{
+ Py_XDECREF(self->referred_object);
+ if (self->referred_bitmap) free(self->referred_bitmap);
+ PyMem_DEL(self);
+}
+
+static PyObject *BMObj_getdata(BitMapObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ int from, length;
+ char *cp;
+
+ if ( !PyArg_ParseTuple(_args, "ii", &from, &length) )
+ return NULL;
+ cp = _self->ob_itself->baseAddr+from;
+ return PyString_FromStringAndSize(cp, length);
+
+}
+
+static PyObject *BMObj_putdata(BitMapObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ int from, length;
+ char *cp, *icp;
+
+ if ( !PyArg_ParseTuple(_args, "is#", &from, &icp, &length) )
+ return NULL;
+ cp = _self->ob_itself->baseAddr+from;
+ memcpy(cp, icp, length);
+ Py_INCREF(Py_None);
+ return Py_None;
+
+}
+
+static PyMethodDef BMObj_methods[] = {
+ {"getdata", (PyCFunction)BMObj_getdata, 1,
+ "(int start, int size) -> string. Return bytes from the bitmap"},
+ {"putdata", (PyCFunction)BMObj_putdata, 1,
+ "(int start, string data). Store bytes into the bitmap"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain BMObj_chain = { BMObj_methods, NULL };
+
+static PyObject *BMObj_getattr(BitMapObject *self, char *name)
+{
+ if ( strcmp(name, "baseAddr") == 0 )
+ return PyInt_FromLong((long)self->ob_itself->baseAddr);
+ if ( strcmp(name, "rowBytes") == 0 )
+ return PyInt_FromLong((long)self->ob_itself->rowBytes);
+ if ( strcmp(name, "bounds") == 0 )
+ return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->bounds);
+ /* XXXX Add more, as needed */
+ if ( strcmp(name, "bitmap_data") == 0 )
+ return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(BitMap));
+ if ( strcmp(name, "pixmap_data") == 0 )
+ return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(PixMap));
+
+ return Py_FindMethodInChain(&BMObj_chain, (PyObject *)self, name);
+}
+
+#define BMObj_setattr NULL
+
+#define BMObj_compare NULL
+
+#define BMObj_repr NULL
+
+#define BMObj_hash NULL
+
+PyTypeObject BitMap_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "BitMap", /*tp_name*/
+ sizeof(BitMapObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) BMObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) BMObj_getattr, /*tp_getattr*/
+ (setattrfunc) BMObj_setattr, /*tp_setattr*/
+ (cmpfunc) BMObj_compare, /*tp_compare*/
+ (reprfunc) BMObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) BMObj_hash, /*tp_hash*/
+};
+
+/* --------------------- End object type BitMap --------------------- */
+
+
+/* ------------------ Object type QDGlobalsAccess ------------------- */
+
+staticforward PyTypeObject QDGlobalsAccess_Type;
+
+#define QDGA_Check(x) ((x)->ob_type == &QDGlobalsAccess_Type)
+
+typedef struct QDGlobalsAccessObject {
+ PyObject_HEAD
+} QDGlobalsAccessObject;
+
+static PyObject *QDGA_New(void)
+{
+ QDGlobalsAccessObject *it;
+ it = PyObject_NEW(QDGlobalsAccessObject, &QDGlobalsAccess_Type);
+ if (it == NULL) return NULL;
+ return (PyObject *)it;
+}
+
+static void QDGA_dealloc(QDGlobalsAccessObject *self)
+{
+ PyMem_DEL(self);
+}
+
+static PyMethodDef QDGA_methods[] = {
+ {NULL, NULL, 0}
+};
+
+static PyMethodChain QDGA_chain = { QDGA_methods, NULL };
+
+static PyObject *QDGA_getattr(QDGlobalsAccessObject *self, char *name)
+{
+#if !ACCESSOR_CALLS_ARE_FUNCTIONS
+
+ if ( strcmp(name, "arrow") == 0 )
+ return PyString_FromStringAndSize((char *)&qd.arrow, sizeof(qd.arrow));
+ if ( strcmp(name, "black") == 0 )
+ return PyString_FromStringAndSize((char *)&qd.black, sizeof(qd.black));
+ if ( strcmp(name, "white") == 0 )
+ return PyString_FromStringAndSize((char *)&qd.white, sizeof(qd.white));
+ if ( strcmp(name, "gray") == 0 )
+ return PyString_FromStringAndSize((char *)&qd.gray, sizeof(qd.gray));
+ if ( strcmp(name, "ltGray") == 0 )
+ return PyString_FromStringAndSize((char *)&qd.ltGray, sizeof(qd.ltGray));
+ if ( strcmp(name, "dkGray") == 0 )
+ return PyString_FromStringAndSize((char *)&qd.dkGray, sizeof(qd.dkGray));
+ if ( strcmp(name, "screenBits") == 0 )
+ return BMObj_New(&qd.screenBits);
+ if ( strcmp(name, "thePort") == 0 )
+ return GrafObj_New(qd.thePort);
+ if ( strcmp(name, "randSeed") == 0 )
+ return Py_BuildValue("l", &qd.randSeed);
+
+#else
+
+ if ( strcmp(name, "arrow") == 0 ) {
+ Cursor rv;
+ GetQDGlobalsArrow(&rv);
+ return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
+ }
+ if ( strcmp(name, "black") == 0 ) {
+ Pattern rv;
+ GetQDGlobalsBlack(&rv);
+ return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
+ }
+ if ( strcmp(name, "white") == 0 ) {
+ Pattern rv;
+ GetQDGlobalsWhite(&rv);
+ return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
+ }
+ if ( strcmp(name, "gray") == 0 ) {
+ Pattern rv;
+ GetQDGlobalsGray(&rv);
+ return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
+ }
+ if ( strcmp(name, "ltGray") == 0 ) {
+ Pattern rv;
+ GetQDGlobalsLightGray(&rv);
+ return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
+ }
+ if ( strcmp(name, "dkGray") == 0 ) {
+ Pattern rv;
+ GetQDGlobalsDarkGray(&rv);
+ return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
+ }
+ if ( strcmp(name, "screenBits") == 0 ) {
+ BitMap rv;
+ GetQDGlobalsScreenBits(&rv);
+ return BMObj_NewCopied(&rv);
+ }
+ if ( strcmp(name, "thePort") == 0 )
+ return GrafObj_New(GetQDGlobalsThePort());
+ if ( strcmp(name, "randSeed") == 0 )
+ return Py_BuildValue("l", GetQDGlobalsRandomSeed());
+
+#endif
+ return Py_FindMethodInChain(&QDGA_chain, (PyObject *)self, name);
+}
+
+#define QDGA_setattr NULL
+
+#define QDGA_compare NULL
+
+#define QDGA_repr NULL
+
+#define QDGA_hash NULL
+
+staticforward PyTypeObject QDGlobalsAccess_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "QDGlobalsAccess", /*tp_name*/
+ sizeof(QDGlobalsAccessObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) QDGA_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) QDGA_getattr, /*tp_getattr*/
+ (setattrfunc) QDGA_setattr, /*tp_setattr*/
+ (cmpfunc) QDGA_compare, /*tp_compare*/
+ (reprfunc) QDGA_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) QDGA_hash, /*tp_hash*/
+};
+
+/* ---------------- End object type QDGlobalsAccess ----------------- */
+
+
+static PyObject *Qd_MacSetPort(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ MacSetPort(port);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_GetPort(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GrafPtr port;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetPort(&port);
+ _res = Py_BuildValue("O&",
+ GrafObj_New, port);
+ return _res;
+}
+
+static PyObject *Qd_GrafDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short device;
+ if (!PyArg_ParseTuple(_args, "h",
+ &device))
+ return NULL;
+ GrafDevice(device);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetPortBits(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ BitMapPtr bm;
+ if (!PyArg_ParseTuple(_args, "O&",
+ BMObj_Convert, &bm))
+ return NULL;
+ SetPortBits(bm);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_PortSize(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short width;
+ short height;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &width,
+ &height))
+ return NULL;
+ PortSize(width,
+ height);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MovePortTo(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short leftGlobal;
+ short topGlobal;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &leftGlobal,
+ &topGlobal))
+ return NULL;
+ MovePortTo(leftGlobal,
+ topGlobal);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetOrigin(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short h;
+ short v;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &h,
+ &v))
+ return NULL;
+ SetOrigin(h,
+ v);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetClip(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &rgn))
+ return NULL;
+ SetClip(rgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_GetClip(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &rgn))
+ return NULL;
+ GetClip(rgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_ClipRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &r))
+ return NULL;
+ ClipRect(&r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_BackPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Pattern *pat__in__;
+ int pat__in_len__;
+ if (!PyArg_ParseTuple(_args, "s#",
+ (char **)&pat__in__, &pat__in_len__))
+ return NULL;
+ if (pat__in_len__ != sizeof(Pattern))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
+ goto pat__error__;
+ }
+ BackPat(pat__in__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ pat__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_InitCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ InitCursor();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacSetCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Cursor *crsr__in__;
+ int crsr__in_len__;
+ if (!PyArg_ParseTuple(_args, "s#",
+ (char **)&crsr__in__, &crsr__in_len__))
+ return NULL;
+ if (crsr__in_len__ != sizeof(Cursor))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Cursor)");
+ goto crsr__error__;
+ }
+ MacSetCursor(crsr__in__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ crsr__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_HideCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ HideCursor();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacShowCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ MacShowCursor();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_ObscureCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ObscureCursor();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_HidePen(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ HidePen();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_ShowPen(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ShowPen();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_GetPen(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point pt;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetPen(&pt);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, pt);
+ return _res;
+}
+
+static PyObject *Qd_GetPenState(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PenState pnState__out__;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetPenState(&pnState__out__);
+ _res = Py_BuildValue("s#",
+ (char *)&pnState__out__, (int)sizeof(PenState));
+ pnState__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_SetPenState(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PenState *pnState__in__;
+ int pnState__in_len__;
+ if (!PyArg_ParseTuple(_args, "s#",
+ (char **)&pnState__in__, &pnState__in_len__))
+ return NULL;
+ if (pnState__in_len__ != sizeof(PenState))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(PenState)");
+ goto pnState__error__;
+ }
+ SetPenState(pnState__in__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ pnState__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_PenSize(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short width;
+ short height;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &width,
+ &height))
+ return NULL;
+ PenSize(width,
+ height);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_PenMode(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short mode;
+ if (!PyArg_ParseTuple(_args, "h",
+ &mode))
+ return NULL;
+ PenMode(mode);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_PenPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Pattern *pat__in__;
+ int pat__in_len__;
+ if (!PyArg_ParseTuple(_args, "s#",
+ (char **)&pat__in__, &pat__in_len__))
+ return NULL;
+ if (pat__in_len__ != sizeof(Pattern))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
+ goto pat__error__;
+ }
+ PenPat(pat__in__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ pat__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_PenNormal(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ PenNormal();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MoveTo(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short h;
+ short v;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &h,
+ &v))
+ return NULL;
+ MoveTo(h,
+ v);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_Move(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short dh;
+ short dv;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &dh,
+ &dv))
+ return NULL;
+ Move(dh,
+ dv);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacLineTo(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short h;
+ short v;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &h,
+ &v))
+ return NULL;
+ MacLineTo(h,
+ v);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_Line(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short dh;
+ short dv;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &dh,
+ &dv))
+ return NULL;
+ Line(dh,
+ dv);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_ForeColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long color;
+ if (!PyArg_ParseTuple(_args, "l",
+ &color))
+ return NULL;
+ ForeColor(color);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_BackColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long color;
+ if (!PyArg_ParseTuple(_args, "l",
+ &color))
+ return NULL;
+ BackColor(color);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_ColorBit(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short whichBit;
+ if (!PyArg_ParseTuple(_args, "h",
+ &whichBit))
+ return NULL;
+ ColorBit(whichBit);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacSetRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short left;
+ short top;
+ short right;
+ short bottom;
+ if (!PyArg_ParseTuple(_args, "hhhh",
+ &left,
+ &top,
+ &right,
+ &bottom))
+ return NULL;
+ MacSetRect(&r,
+ left,
+ top,
+ right,
+ bottom);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &r);
+ return _res;
+}
+
+static PyObject *Qd_MacOffsetRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short dh;
+ short dv;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetRect, &r,
+ &dh,
+ &dv))
+ return NULL;
+ MacOffsetRect(&r,
+ dh,
+ dv);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &r);
+ return _res;
+}
+
+static PyObject *Qd_MacInsetRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short dh;
+ short dv;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetRect, &r,
+ &dh,
+ &dv))
+ return NULL;
+ MacInsetRect(&r,
+ dh,
+ dv);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &r);
+ return _res;
+}
+
+static PyObject *Qd_SectRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Rect src1;
+ Rect src2;
+ Rect dstRect;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &src1,
+ PyMac_GetRect, &src2))
+ return NULL;
+ _rv = SectRect(&src1,
+ &src2,
+ &dstRect);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildRect, &dstRect);
+ return _res;
+}
+
+static PyObject *Qd_MacUnionRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect src1;
+ Rect src2;
+ Rect dstRect;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &src1,
+ PyMac_GetRect, &src2))
+ return NULL;
+ MacUnionRect(&src1,
+ &src2,
+ &dstRect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &dstRect);
+ return _res;
+}
+
+static PyObject *Qd_MacEqualRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Rect rect1;
+ Rect rect2;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &rect1,
+ PyMac_GetRect, &rect2))
+ return NULL;
+ _rv = MacEqualRect(&rect1,
+ &rect2);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_EmptyRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &r))
+ return NULL;
+ _rv = EmptyRect(&r);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_MacFrameRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &r))
+ return NULL;
+ MacFrameRect(&r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_PaintRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &r))
+ return NULL;
+ PaintRect(&r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_EraseRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &r))
+ return NULL;
+ EraseRect(&r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacInvertRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &r))
+ return NULL;
+ MacInvertRect(&r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacFillRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ Pattern *pat__in__;
+ int pat__in_len__;
+ if (!PyArg_ParseTuple(_args, "O&s#",
+ PyMac_GetRect, &r,
+ (char **)&pat__in__, &pat__in_len__))
+ return NULL;
+ if (pat__in_len__ != sizeof(Pattern))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
+ goto pat__error__;
+ }
+ MacFillRect(&r,
+ pat__in__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ pat__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_FrameOval(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &r))
+ return NULL;
+ FrameOval(&r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_PaintOval(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &r))
+ return NULL;
+ PaintOval(&r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_EraseOval(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &r))
+ return NULL;
+ EraseOval(&r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_InvertOval(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &r))
+ return NULL;
+ InvertOval(&r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_FillOval(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ Pattern *pat__in__;
+ int pat__in_len__;
+ if (!PyArg_ParseTuple(_args, "O&s#",
+ PyMac_GetRect, &r,
+ (char **)&pat__in__, &pat__in_len__))
+ return NULL;
+ if (pat__in_len__ != sizeof(Pattern))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
+ goto pat__error__;
+ }
+ FillOval(&r,
+ pat__in__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ pat__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_FrameRoundRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short ovalWidth;
+ short ovalHeight;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetRect, &r,
+ &ovalWidth,
+ &ovalHeight))
+ return NULL;
+ FrameRoundRect(&r,
+ ovalWidth,
+ ovalHeight);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_PaintRoundRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short ovalWidth;
+ short ovalHeight;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetRect, &r,
+ &ovalWidth,
+ &ovalHeight))
+ return NULL;
+ PaintRoundRect(&r,
+ ovalWidth,
+ ovalHeight);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_EraseRoundRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short ovalWidth;
+ short ovalHeight;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetRect, &r,
+ &ovalWidth,
+ &ovalHeight))
+ return NULL;
+ EraseRoundRect(&r,
+ ovalWidth,
+ ovalHeight);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_InvertRoundRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short ovalWidth;
+ short ovalHeight;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetRect, &r,
+ &ovalWidth,
+ &ovalHeight))
+ return NULL;
+ InvertRoundRect(&r,
+ ovalWidth,
+ ovalHeight);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_FillRoundRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short ovalWidth;
+ short ovalHeight;
+ Pattern *pat__in__;
+ int pat__in_len__;
+ if (!PyArg_ParseTuple(_args, "O&hhs#",
+ PyMac_GetRect, &r,
+ &ovalWidth,
+ &ovalHeight,
+ (char **)&pat__in__, &pat__in_len__))
+ return NULL;
+ if (pat__in_len__ != sizeof(Pattern))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
+ goto pat__error__;
+ }
+ FillRoundRect(&r,
+ ovalWidth,
+ ovalHeight,
+ pat__in__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ pat__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_FrameArc(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short startAngle;
+ short arcAngle;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetRect, &r,
+ &startAngle,
+ &arcAngle))
+ return NULL;
+ FrameArc(&r,
+ startAngle,
+ arcAngle);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_PaintArc(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short startAngle;
+ short arcAngle;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetRect, &r,
+ &startAngle,
+ &arcAngle))
+ return NULL;
+ PaintArc(&r,
+ startAngle,
+ arcAngle);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_EraseArc(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short startAngle;
+ short arcAngle;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetRect, &r,
+ &startAngle,
+ &arcAngle))
+ return NULL;
+ EraseArc(&r,
+ startAngle,
+ arcAngle);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_InvertArc(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short startAngle;
+ short arcAngle;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetRect, &r,
+ &startAngle,
+ &arcAngle))
+ return NULL;
+ InvertArc(&r,
+ startAngle,
+ arcAngle);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_FillArc(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short startAngle;
+ short arcAngle;
+ Pattern *pat__in__;
+ int pat__in_len__;
+ if (!PyArg_ParseTuple(_args, "O&hhs#",
+ PyMac_GetRect, &r,
+ &startAngle,
+ &arcAngle,
+ (char **)&pat__in__, &pat__in_len__))
+ return NULL;
+ if (pat__in_len__ != sizeof(Pattern))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
+ goto pat__error__;
+ }
+ FillArc(&r,
+ startAngle,
+ arcAngle,
+ pat__in__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ pat__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_NewRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = NewRgn();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_OpenRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ OpenRgn();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_CloseRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle dstRgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &dstRgn))
+ return NULL;
+ CloseRgn(dstRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_BitMapToRegion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ RgnHandle region;
+ BitMapPtr bMap;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, ®ion,
+ BMObj_Convert, &bMap))
+ return NULL;
+ _err = BitMapToRegion(region,
+ bMap);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_DisposeRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &rgn))
+ return NULL;
+ DisposeRgn(rgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacCopyRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle srcRgn;
+ RgnHandle dstRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &srcRgn,
+ ResObj_Convert, &dstRgn))
+ return NULL;
+ MacCopyRgn(srcRgn,
+ dstRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetEmptyRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &rgn))
+ return NULL;
+ SetEmptyRgn(rgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacSetRectRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ short left;
+ short top;
+ short right;
+ short bottom;
+ if (!PyArg_ParseTuple(_args, "O&hhhh",
+ ResObj_Convert, &rgn,
+ &left,
+ &top,
+ &right,
+ &bottom))
+ return NULL;
+ MacSetRectRgn(rgn,
+ left,
+ top,
+ right,
+ bottom);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_RectRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &rgn,
+ PyMac_GetRect, &r))
+ return NULL;
+ RectRgn(rgn,
+ &r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacOffsetRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ short dh;
+ short dv;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ ResObj_Convert, &rgn,
+ &dh,
+ &dv))
+ return NULL;
+ MacOffsetRgn(rgn,
+ dh,
+ dv);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_InsetRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ short dh;
+ short dv;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ ResObj_Convert, &rgn,
+ &dh,
+ &dv))
+ return NULL;
+ InsetRgn(rgn,
+ dh,
+ dv);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SectRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle srcRgnA;
+ RgnHandle srcRgnB;
+ RgnHandle dstRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ ResObj_Convert, &srcRgnA,
+ ResObj_Convert, &srcRgnB,
+ ResObj_Convert, &dstRgn))
+ return NULL;
+ SectRgn(srcRgnA,
+ srcRgnB,
+ dstRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacUnionRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle srcRgnA;
+ RgnHandle srcRgnB;
+ RgnHandle dstRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ ResObj_Convert, &srcRgnA,
+ ResObj_Convert, &srcRgnB,
+ ResObj_Convert, &dstRgn))
+ return NULL;
+ MacUnionRgn(srcRgnA,
+ srcRgnB,
+ dstRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_DiffRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle srcRgnA;
+ RgnHandle srcRgnB;
+ RgnHandle dstRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ ResObj_Convert, &srcRgnA,
+ ResObj_Convert, &srcRgnB,
+ ResObj_Convert, &dstRgn))
+ return NULL;
+ DiffRgn(srcRgnA,
+ srcRgnB,
+ dstRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacXorRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle srcRgnA;
+ RgnHandle srcRgnB;
+ RgnHandle dstRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ ResObj_Convert, &srcRgnA,
+ ResObj_Convert, &srcRgnB,
+ ResObj_Convert, &dstRgn))
+ return NULL;
+ MacXorRgn(srcRgnA,
+ srcRgnB,
+ dstRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_RectInRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Rect r;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &r,
+ ResObj_Convert, &rgn))
+ return NULL;
+ _rv = RectInRgn(&r,
+ rgn);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_MacEqualRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ RgnHandle rgnA;
+ RgnHandle rgnB;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &rgnA,
+ ResObj_Convert, &rgnB))
+ return NULL;
+ _rv = MacEqualRgn(rgnA,
+ rgnB);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_EmptyRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &rgn))
+ return NULL;
+ _rv = EmptyRgn(rgn);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_MacFrameRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &rgn))
+ return NULL;
+ MacFrameRgn(rgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacPaintRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &rgn))
+ return NULL;
+ MacPaintRgn(rgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_EraseRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &rgn))
+ return NULL;
+ EraseRgn(rgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacInvertRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &rgn))
+ return NULL;
+ MacInvertRgn(rgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacFillRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ Pattern *pat__in__;
+ int pat__in_len__;
+ if (!PyArg_ParseTuple(_args, "O&s#",
+ ResObj_Convert, &rgn,
+ (char **)&pat__in__, &pat__in_len__))
+ return NULL;
+ if (pat__in_len__ != sizeof(Pattern))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
+ goto pat__error__;
+ }
+ MacFillRgn(rgn,
+ pat__in__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ pat__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_ScrollRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short dh;
+ short dv;
+ RgnHandle updateRgn;
+ if (!PyArg_ParseTuple(_args, "O&hhO&",
+ PyMac_GetRect, &r,
+ &dh,
+ &dv,
+ ResObj_Convert, &updateRgn))
+ return NULL;
+ ScrollRect(&r,
+ dh,
+ dv,
+ updateRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_CopyBits(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ BitMapPtr srcBits;
+ BitMapPtr dstBits;
+ Rect srcRect;
+ Rect dstRect;
+ short mode;
+ RgnHandle maskRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&hO&",
+ BMObj_Convert, &srcBits,
+ BMObj_Convert, &dstBits,
+ PyMac_GetRect, &srcRect,
+ PyMac_GetRect, &dstRect,
+ &mode,
+ OptResObj_Convert, &maskRgn))
+ return NULL;
+ CopyBits(srcBits,
+ dstBits,
+ &srcRect,
+ &dstRect,
+ mode,
+ maskRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_CopyMask(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ BitMapPtr srcBits;
+ BitMapPtr maskBits;
+ BitMapPtr dstBits;
+ Rect srcRect;
+ Rect maskRect;
+ Rect dstRect;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&O&O&",
+ BMObj_Convert, &srcBits,
+ BMObj_Convert, &maskBits,
+ BMObj_Convert, &dstBits,
+ PyMac_GetRect, &srcRect,
+ PyMac_GetRect, &maskRect,
+ PyMac_GetRect, &dstRect))
+ return NULL;
+ CopyMask(srcBits,
+ maskBits,
+ dstBits,
+ &srcRect,
+ &maskRect,
+ &dstRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_OpenPicture(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PicHandle _rv;
+ Rect picFrame;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &picFrame))
+ return NULL;
+ _rv = OpenPicture(&picFrame);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_PicComment(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short kind;
+ short dataSize;
+ Handle dataHandle;
+ if (!PyArg_ParseTuple(_args, "hhO&",
+ &kind,
+ &dataSize,
+ ResObj_Convert, &dataHandle))
+ return NULL;
+ PicComment(kind,
+ dataSize,
+ dataHandle);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_ClosePicture(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ClosePicture();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_DrawPicture(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PicHandle myPicture;
+ Rect dstRect;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &myPicture,
+ PyMac_GetRect, &dstRect))
+ return NULL;
+ DrawPicture(myPicture,
+ &dstRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_KillPicture(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PicHandle myPicture;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &myPicture))
+ return NULL;
+ KillPicture(myPicture);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_OpenPoly(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PolyHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = OpenPoly();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_ClosePoly(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ClosePoly();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_KillPoly(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PolyHandle poly;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &poly))
+ return NULL;
+ KillPoly(poly);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_OffsetPoly(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PolyHandle poly;
+ short dh;
+ short dv;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ ResObj_Convert, &poly,
+ &dh,
+ &dv))
+ return NULL;
+ OffsetPoly(poly,
+ dh,
+ dv);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_FramePoly(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PolyHandle poly;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &poly))
+ return NULL;
+ FramePoly(poly);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_PaintPoly(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PolyHandle poly;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &poly))
+ return NULL;
+ PaintPoly(poly);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_ErasePoly(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PolyHandle poly;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &poly))
+ return NULL;
+ ErasePoly(poly);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_InvertPoly(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PolyHandle poly;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &poly))
+ return NULL;
+ InvertPoly(poly);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_FillPoly(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PolyHandle poly;
+ Pattern *pat__in__;
+ int pat__in_len__;
+ if (!PyArg_ParseTuple(_args, "O&s#",
+ ResObj_Convert, &poly,
+ (char **)&pat__in__, &pat__in_len__))
+ return NULL;
+ if (pat__in_len__ != sizeof(Pattern))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
+ goto pat__error__;
+ }
+ FillPoly(poly,
+ pat__in__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ pat__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_SetPt(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point pt;
+ short h;
+ short v;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &h,
+ &v))
+ return NULL;
+ SetPt(&pt,
+ h,
+ v);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, pt);
+ return _res;
+}
+
+static PyObject *Qd_LocalToGlobal(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point pt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &pt))
+ return NULL;
+ LocalToGlobal(&pt);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, pt);
+ return _res;
+}
+
+static PyObject *Qd_GlobalToLocal(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point pt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &pt))
+ return NULL;
+ GlobalToLocal(&pt);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, pt);
+ return _res;
+}
+
+static PyObject *Qd_Random(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = Random();
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_MacGetPixel(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ short h;
+ short v;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &h,
+ &v))
+ return NULL;
+ _rv = MacGetPixel(h,
+ v);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_ScalePt(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point pt;
+ Rect srcRect;
+ Rect dstRect;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ PyMac_GetPoint, &pt,
+ PyMac_GetRect, &srcRect,
+ PyMac_GetRect, &dstRect))
+ return NULL;
+ ScalePt(&pt,
+ &srcRect,
+ &dstRect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, pt);
+ return _res;
+}
+
+static PyObject *Qd_MapPt(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point pt;
+ Rect srcRect;
+ Rect dstRect;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ PyMac_GetPoint, &pt,
+ PyMac_GetRect, &srcRect,
+ PyMac_GetRect, &dstRect))
+ return NULL;
+ MapPt(&pt,
+ &srcRect,
+ &dstRect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, pt);
+ return _res;
+}
+
+static PyObject *Qd_MapRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ Rect srcRect;
+ Rect dstRect;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ PyMac_GetRect, &r,
+ PyMac_GetRect, &srcRect,
+ PyMac_GetRect, &dstRect))
+ return NULL;
+ MapRect(&r,
+ &srcRect,
+ &dstRect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &r);
+ return _res;
+}
+
+static PyObject *Qd_MapRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ Rect srcRect;
+ Rect dstRect;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ ResObj_Convert, &rgn,
+ PyMac_GetRect, &srcRect,
+ PyMac_GetRect, &dstRect))
+ return NULL;
+ MapRgn(rgn,
+ &srcRect,
+ &dstRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MapPoly(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PolyHandle poly;
+ Rect srcRect;
+ Rect dstRect;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ ResObj_Convert, &poly,
+ PyMac_GetRect, &srcRect,
+ PyMac_GetRect, &dstRect))
+ return NULL;
+ MapPoly(poly,
+ &srcRect,
+ &dstRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_StdBits(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ BitMapPtr srcBits;
+ Rect srcRect;
+ Rect dstRect;
+ short mode;
+ RgnHandle maskRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&O&hO&",
+ BMObj_Convert, &srcBits,
+ PyMac_GetRect, &srcRect,
+ PyMac_GetRect, &dstRect,
+ &mode,
+ OptResObj_Convert, &maskRgn))
+ return NULL;
+ StdBits(srcBits,
+ &srcRect,
+ &dstRect,
+ mode,
+ maskRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_AddPt(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point src;
+ Point dst;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &src,
+ PyMac_GetPoint, &dst))
+ return NULL;
+ AddPt(src,
+ &dst);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, dst);
+ return _res;
+}
+
+static PyObject *Qd_EqualPt(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point pt1;
+ Point pt2;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &pt1,
+ PyMac_GetPoint, &pt2))
+ return NULL;
+ _rv = EqualPt(pt1,
+ pt2);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_MacPtInRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point pt;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &pt,
+ PyMac_GetRect, &r))
+ return NULL;
+ _rv = MacPtInRect(pt,
+ &r);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_Pt2Rect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point pt1;
+ Point pt2;
+ Rect dstRect;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &pt1,
+ PyMac_GetPoint, &pt2))
+ return NULL;
+ Pt2Rect(pt1,
+ pt2,
+ &dstRect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &dstRect);
+ return _res;
+}
+
+static PyObject *Qd_PtToAngle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ Point pt;
+ short angle;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &r,
+ PyMac_GetPoint, &pt))
+ return NULL;
+ PtToAngle(&r,
+ pt,
+ &angle);
+ _res = Py_BuildValue("h",
+ angle);
+ return _res;
+}
+
+static PyObject *Qd_SubPt(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point src;
+ Point dst;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &src,
+ PyMac_GetPoint, &dst))
+ return NULL;
+ SubPt(src,
+ &dst);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, dst);
+ return _res;
+}
+
+static PyObject *Qd_PtInRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point pt;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &pt,
+ ResObj_Convert, &rgn))
+ return NULL;
+ _rv = PtInRgn(pt,
+ rgn);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_NewPixMap(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = NewPixMap();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_DisposePixMap(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle pm;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pm))
+ return NULL;
+ DisposePixMap(pm);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_CopyPixMap(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle srcPM;
+ PixMapHandle dstPM;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &srcPM,
+ ResObj_Convert, &dstPM))
+ return NULL;
+ CopyPixMap(srcPM,
+ dstPM);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_NewPixPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixPatHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = NewPixPat();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_DisposePixPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixPatHandle pp;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pp))
+ return NULL;
+ DisposePixPat(pp);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_CopyPixPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixPatHandle srcPP;
+ PixPatHandle dstPP;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &srcPP,
+ ResObj_Convert, &dstPP))
+ return NULL;
+ CopyPixPat(srcPP,
+ dstPP);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_PenPixPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixPatHandle pp;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pp))
+ return NULL;
+ PenPixPat(pp);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_BackPixPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixPatHandle pp;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pp))
+ return NULL;
+ BackPixPat(pp);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_GetPixPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixPatHandle _rv;
+ short patID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &patID))
+ return NULL;
+ _rv = GetPixPat(patID);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_MakeRGBPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixPatHandle pp;
+ RGBColor myColor;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &pp,
+ QdRGB_Convert, &myColor))
+ return NULL;
+ MakeRGBPat(pp,
+ &myColor);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_FillCRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ PixPatHandle pp;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &r,
+ ResObj_Convert, &pp))
+ return NULL;
+ FillCRect(&r,
+ pp);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_FillCOval(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ PixPatHandle pp;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &r,
+ ResObj_Convert, &pp))
+ return NULL;
+ FillCOval(&r,
+ pp);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_FillCRoundRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short ovalWidth;
+ short ovalHeight;
+ PixPatHandle pp;
+ if (!PyArg_ParseTuple(_args, "O&hhO&",
+ PyMac_GetRect, &r,
+ &ovalWidth,
+ &ovalHeight,
+ ResObj_Convert, &pp))
+ return NULL;
+ FillCRoundRect(&r,
+ ovalWidth,
+ ovalHeight,
+ pp);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_FillCArc(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short startAngle;
+ short arcAngle;
+ PixPatHandle pp;
+ if (!PyArg_ParseTuple(_args, "O&hhO&",
+ PyMac_GetRect, &r,
+ &startAngle,
+ &arcAngle,
+ ResObj_Convert, &pp))
+ return NULL;
+ FillCArc(&r,
+ startAngle,
+ arcAngle,
+ pp);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_FillCRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ PixPatHandle pp;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &rgn,
+ ResObj_Convert, &pp))
+ return NULL;
+ FillCRgn(rgn,
+ pp);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_FillCPoly(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PolyHandle poly;
+ PixPatHandle pp;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &poly,
+ ResObj_Convert, &pp))
+ return NULL;
+ FillCPoly(poly,
+ pp);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_RGBForeColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RGBColor color;
+ if (!PyArg_ParseTuple(_args, "O&",
+ QdRGB_Convert, &color))
+ return NULL;
+ RGBForeColor(&color);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_RGBBackColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RGBColor color;
+ if (!PyArg_ParseTuple(_args, "O&",
+ QdRGB_Convert, &color))
+ return NULL;
+ RGBBackColor(&color);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetCPixel(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short h;
+ short v;
+ RGBColor cPix;
+ if (!PyArg_ParseTuple(_args, "hhO&",
+ &h,
+ &v,
+ QdRGB_Convert, &cPix))
+ return NULL;
+ SetCPixel(h,
+ v,
+ &cPix);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetPortPix(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle pm;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pm))
+ return NULL;
+ SetPortPix(pm);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_GetCPixel(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short h;
+ short v;
+ RGBColor cPix;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &h,
+ &v))
+ return NULL;
+ GetCPixel(h,
+ v,
+ &cPix);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &cPix);
+ return _res;
+}
+
+static PyObject *Qd_GetForeColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RGBColor color;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetForeColor(&color);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &color);
+ return _res;
+}
+
+static PyObject *Qd_GetBackColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RGBColor color;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetBackColor(&color);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &color);
+ return _res;
+}
+
+static PyObject *Qd_OpColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RGBColor color;
+ if (!PyArg_ParseTuple(_args, "O&",
+ QdRGB_Convert, &color))
+ return NULL;
+ OpColor(&color);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_HiliteColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RGBColor color;
+ if (!PyArg_ParseTuple(_args, "O&",
+ QdRGB_Convert, &color))
+ return NULL;
+ HiliteColor(&color);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_DisposeCTable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CTabHandle cTable;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &cTable))
+ return NULL;
+ DisposeCTable(cTable);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_GetCTable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CTabHandle _rv;
+ short ctID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &ctID))
+ return NULL;
+ _rv = GetCTable(ctID);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetCCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CCrsrHandle _rv;
+ short crsrID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &crsrID))
+ return NULL;
+ _rv = GetCCursor(crsrID);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_SetCCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CCrsrHandle cCrsr;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &cCrsr))
+ return NULL;
+ SetCCursor(cCrsr);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_AllocCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ AllocCursor();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_DisposeCCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CCrsrHandle cCrsr;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &cCrsr))
+ return NULL;
+ DisposeCCursor(cCrsr);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_GetMaxDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle _rv;
+ Rect globalRect;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &globalRect))
+ return NULL;
+ _rv = GetMaxDevice(&globalRect);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetCTSeed(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetCTSeed();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetDeviceList(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetDeviceList();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetMainDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMainDevice();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetNextDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle _rv;
+ GDHandle curDevice;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &curDevice))
+ return NULL;
+ _rv = GetNextDevice(curDevice);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_TestDeviceAttribute(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ GDHandle gdh;
+ short attribute;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ ResObj_Convert, &gdh,
+ &attribute))
+ return NULL;
+ _rv = TestDeviceAttribute(gdh,
+ attribute);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_SetDeviceAttribute(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle gdh;
+ short attribute;
+ Boolean value;
+ if (!PyArg_ParseTuple(_args, "O&hb",
+ ResObj_Convert, &gdh,
+ &attribute,
+ &value))
+ return NULL;
+ SetDeviceAttribute(gdh,
+ attribute,
+ value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_InitGDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short qdRefNum;
+ long mode;
+ GDHandle gdh;
+ if (!PyArg_ParseTuple(_args, "hlO&",
+ &qdRefNum,
+ &mode,
+ ResObj_Convert, &gdh))
+ return NULL;
+ InitGDevice(qdRefNum,
+ mode,
+ gdh);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_NewGDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle _rv;
+ short refNum;
+ long mode;
+ if (!PyArg_ParseTuple(_args, "hl",
+ &refNum,
+ &mode))
+ return NULL;
+ _rv = NewGDevice(refNum,
+ mode);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_DisposeGDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle gdh;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &gdh))
+ return NULL;
+ DisposeGDevice(gdh);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetGDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle gd;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &gd))
+ return NULL;
+ SetGDevice(gd);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_GetGDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetGDevice();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_Color2Index(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ RGBColor myColor;
+ if (!PyArg_ParseTuple(_args, "O&",
+ QdRGB_Convert, &myColor))
+ return NULL;
+ _rv = Color2Index(&myColor);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_Index2Color(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long index;
+ RGBColor aColor;
+ if (!PyArg_ParseTuple(_args, "l",
+ &index))
+ return NULL;
+ Index2Color(index,
+ &aColor);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &aColor);
+ return _res;
+}
+
+static PyObject *Qd_InvertColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RGBColor myColor;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ InvertColor(&myColor);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &myColor);
+ return _res;
+}
+
+static PyObject *Qd_RealColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ RGBColor color;
+ if (!PyArg_ParseTuple(_args, "O&",
+ QdRGB_Convert, &color))
+ return NULL;
+ _rv = RealColor(&color);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetSubTable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CTabHandle myColors;
+ short iTabRes;
+ CTabHandle targetTbl;
+ if (!PyArg_ParseTuple(_args, "O&hO&",
+ ResObj_Convert, &myColors,
+ &iTabRes,
+ ResObj_Convert, &targetTbl))
+ return NULL;
+ GetSubTable(myColors,
+ iTabRes,
+ targetTbl);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MakeITable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CTabHandle cTabH;
+ ITabHandle iTabH;
+ short res;
+ if (!PyArg_ParseTuple(_args, "O&O&h",
+ ResObj_Convert, &cTabH,
+ ResObj_Convert, &iTabH,
+ &res))
+ return NULL;
+ MakeITable(cTabH,
+ iTabH,
+ res);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetClientID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short id;
+ if (!PyArg_ParseTuple(_args, "h",
+ &id))
+ return NULL;
+ SetClientID(id);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_ProtectEntry(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short index;
+ Boolean protect;
+ if (!PyArg_ParseTuple(_args, "hb",
+ &index,
+ &protect))
+ return NULL;
+ ProtectEntry(index,
+ protect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_ReserveEntry(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short index;
+ Boolean reserve;
+ if (!PyArg_ParseTuple(_args, "hb",
+ &index,
+ &reserve))
+ return NULL;
+ ReserveEntry(index,
+ reserve);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_QDError(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = QDError();
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_CopyDeepMask(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ BitMapPtr srcBits;
+ BitMapPtr maskBits;
+ BitMapPtr dstBits;
+ Rect srcRect;
+ Rect maskRect;
+ Rect dstRect;
+ short mode;
+ RgnHandle maskRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&O&O&hO&",
+ BMObj_Convert, &srcBits,
+ BMObj_Convert, &maskBits,
+ BMObj_Convert, &dstBits,
+ PyMac_GetRect, &srcRect,
+ PyMac_GetRect, &maskRect,
+ PyMac_GetRect, &dstRect,
+ &mode,
+ OptResObj_Convert, &maskRgn))
+ return NULL;
+ CopyDeepMask(srcBits,
+ maskBits,
+ dstBits,
+ &srcRect,
+ &maskRect,
+ &dstRect,
+ mode,
+ maskRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_GetPattern(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PatHandle _rv;
+ short patternID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &patternID))
+ return NULL;
+ _rv = GetPattern(patternID);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_MacGetCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CursHandle _rv;
+ short cursorID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &cursorID))
+ return NULL;
+ _rv = MacGetCursor(cursorID);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPicture(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PicHandle _rv;
+ short pictureID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &pictureID))
+ return NULL;
+ _rv = GetPicture(pictureID);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_DeltaPoint(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ Point ptA;
+ Point ptB;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &ptA,
+ PyMac_GetPoint, &ptB))
+ return NULL;
+ _rv = DeltaPoint(ptA,
+ ptB);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_ShieldCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect shieldRect;
+ Point offsetPt;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &shieldRect,
+ PyMac_GetPoint, &offsetPt))
+ return NULL;
+ ShieldCursor(&shieldRect,
+ offsetPt);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_ScreenRes(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short scrnHRes;
+ short scrnVRes;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ScreenRes(&scrnHRes,
+ &scrnVRes);
+ _res = Py_BuildValue("hh",
+ scrnHRes,
+ scrnVRes);
+ return _res;
+}
+
+static PyObject *Qd_GetIndPattern(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Pattern thePat__out__;
+ short patternListID;
+ short index;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &patternListID,
+ &index))
+ return NULL;
+ GetIndPattern(&thePat__out__,
+ patternListID,
+ index);
+ _res = Py_BuildValue("s#",
+ (char *)&thePat__out__, (int)sizeof(Pattern));
+ thePat__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_SlopeFromAngle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Fixed _rv;
+ short angle;
+ if (!PyArg_ParseTuple(_args, "h",
+ &angle))
+ return NULL;
+ _rv = SlopeFromAngle(angle);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildFixed, _rv);
+ return _res;
+}
+
+static PyObject *Qd_AngleFromSlope(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ Fixed slope;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFixed, &slope))
+ return NULL;
+ _rv = AngleFromSlope(slope);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortPixMap(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = GetPortPixMap(port);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortBitMapForCopyBits(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ const BitMap * _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = GetPortBitMapForCopyBits(port);
+ _res = Py_BuildValue("O&",
+ BMObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortBounds(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ Rect rect;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ GetPortBounds(port,
+ &rect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &rect);
+ return _res;
+}
+
+static PyObject *Qd_GetPortForeColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ RGBColor foreColor;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ GetPortForeColor(port,
+ &foreColor);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &foreColor);
+ return _res;
+}
+
+static PyObject *Qd_GetPortBackColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ RGBColor backColor;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ GetPortBackColor(port,
+ &backColor);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &backColor);
+ return _res;
+}
+
+static PyObject *Qd_GetPortOpColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ RGBColor opColor;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ GetPortOpColor(port,
+ &opColor);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &opColor);
+ return _res;
+}
+
+static PyObject *Qd_GetPortHiliteColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ RGBColor hiliteColor;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ GetPortHiliteColor(port,
+ &hiliteColor);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &hiliteColor);
+ return _res;
+}
+
+static PyObject *Qd_GetPortTextFont(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = GetPortTextFont(port);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortTextFace(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Style _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = GetPortTextFace(port);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortTextMode(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = GetPortTextMode(port);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortTextSize(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = GetPortTextSize(port);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortChExtra(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = GetPortChExtra(port);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortFracHPenLocation(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = GetPortFracHPenLocation(port);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortSpExtra(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Fixed _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = GetPortSpExtra(port);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildFixed, _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortPenVisibility(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = GetPortPenVisibility(port);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortVisibleRegion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ CGrafPtr port;
+ RgnHandle visRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ ResObj_Convert, &visRgn))
+ return NULL;
+ _rv = GetPortVisibleRegion(port,
+ visRgn);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortClipRegion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ CGrafPtr port;
+ RgnHandle clipRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ ResObj_Convert, &clipRgn))
+ return NULL;
+ _rv = GetPortClipRegion(port,
+ clipRgn);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortBackPixPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixPatHandle _rv;
+ CGrafPtr port;
+ PixPatHandle backPattern;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ ResObj_Convert, &backPattern))
+ return NULL;
+ _rv = GetPortBackPixPat(port,
+ backPattern);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortPenPixPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixPatHandle _rv;
+ CGrafPtr port;
+ PixPatHandle penPattern;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ ResObj_Convert, &penPattern))
+ return NULL;
+ _rv = GetPortPenPixPat(port,
+ penPattern);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortFillPixPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixPatHandle _rv;
+ CGrafPtr port;
+ PixPatHandle fillPattern;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ ResObj_Convert, &fillPattern))
+ return NULL;
+ _rv = GetPortFillPixPat(port,
+ fillPattern);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortPenSize(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ Point penSize;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ PyMac_GetPoint, &penSize))
+ return NULL;
+ GetPortPenSize(port,
+ &penSize);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, penSize);
+ return _res;
+}
+
+static PyObject *Qd_GetPortPenMode(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt32 _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = GetPortPenMode(port);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetPortPenLocation(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ Point penLocation;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ PyMac_GetPoint, &penLocation))
+ return NULL;
+ GetPortPenLocation(port,
+ &penLocation);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, penLocation);
+ return _res;
+}
+
+static PyObject *Qd_IsPortRegionBeingDefined(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = IsPortRegionBeingDefined(port);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_IsPortPictureBeingDefined(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = IsPortPictureBeingDefined(port);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Qd_IsPortOffscreen(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = IsPortOffscreen(port);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Qd_IsPortColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = IsPortColor(port);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *Qd_SetPortBounds(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ Rect rect;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ PyMac_GetRect, &rect))
+ return NULL;
+ SetPortBounds(port,
+ &rect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetPortOpColor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ RGBColor opColor;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ QdRGB_Convert, &opColor))
+ return NULL;
+ SetPortOpColor(port,
+ &opColor);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetPortVisibleRegion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ RgnHandle visRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ ResObj_Convert, &visRgn))
+ return NULL;
+ SetPortVisibleRegion(port,
+ visRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetPortClipRegion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ RgnHandle clipRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ ResObj_Convert, &clipRgn))
+ return NULL;
+ SetPortClipRegion(port,
+ clipRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetPortPenPixPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ PixPatHandle penPattern;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ ResObj_Convert, &penPattern))
+ return NULL;
+ SetPortPenPixPat(port,
+ penPattern);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetPortBackPixPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ PixPatHandle backPattern;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ ResObj_Convert, &backPattern))
+ return NULL;
+ SetPortBackPixPat(port,
+ backPattern);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetPortPenSize(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ Point penSize;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ PyMac_GetPoint, &penSize))
+ return NULL;
+ SetPortPenSize(port,
+ penSize);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetPortPenMode(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ SInt32 penMode;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ GrafObj_Convert, &port,
+ &penMode))
+ return NULL;
+ SetPortPenMode(port,
+ penMode);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetPortFracHPenLocation(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ short pnLocHFrac;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ GrafObj_Convert, &port,
+ &pnLocHFrac))
+ return NULL;
+ SetPortFracHPenLocation(port,
+ pnLocHFrac);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_GetPixBounds(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle pixMap;
+ Rect bounds;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pixMap))
+ return NULL;
+ GetPixBounds(pixMap,
+ &bounds);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &bounds);
+ return _res;
+}
+
+static PyObject *Qd_GetPixDepth(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ PixMapHandle pixMap;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pixMap))
+ return NULL;
+ _rv = GetPixDepth(pixMap);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetQDGlobalsRandomSeed(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetQDGlobalsRandomSeed();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_GetQDGlobalsScreenBits(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ BitMap screenBits;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetQDGlobalsScreenBits(&screenBits);
+ _res = Py_BuildValue("O&",
+ BMObj_NewCopied, &screenBits);
+ return _res;
+}
+
+static PyObject *Qd_GetQDGlobalsArrow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Cursor arrow__out__;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetQDGlobalsArrow(&arrow__out__);
+ _res = Py_BuildValue("s#",
+ (char *)&arrow__out__, (int)sizeof(Cursor));
+ arrow__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_GetQDGlobalsDarkGray(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Pattern dkGray__out__;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetQDGlobalsDarkGray(&dkGray__out__);
+ _res = Py_BuildValue("s#",
+ (char *)&dkGray__out__, (int)sizeof(Pattern));
+ dkGray__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_GetQDGlobalsLightGray(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Pattern ltGray__out__;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetQDGlobalsLightGray(<Gray__out__);
+ _res = Py_BuildValue("s#",
+ (char *)<Gray__out__, (int)sizeof(Pattern));
+ ltGray__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_GetQDGlobalsGray(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Pattern gray__out__;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetQDGlobalsGray(&gray__out__);
+ _res = Py_BuildValue("s#",
+ (char *)&gray__out__, (int)sizeof(Pattern));
+ gray__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_GetQDGlobalsBlack(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Pattern black__out__;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetQDGlobalsBlack(&black__out__);
+ _res = Py_BuildValue("s#",
+ (char *)&black__out__, (int)sizeof(Pattern));
+ black__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_GetQDGlobalsWhite(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Pattern white__out__;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetQDGlobalsWhite(&white__out__);
+ _res = Py_BuildValue("s#",
+ (char *)&white__out__, (int)sizeof(Pattern));
+ white__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_GetQDGlobalsThePort(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetQDGlobalsThePort();
+ _res = Py_BuildValue("O&",
+ GrafObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_SetQDGlobalsRandomSeed(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long randomSeed;
+ if (!PyArg_ParseTuple(_args, "l",
+ &randomSeed))
+ return NULL;
+ SetQDGlobalsRandomSeed(randomSeed);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetQDGlobalsArrow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Cursor *arrow__in__;
+ int arrow__in_len__;
+ if (!PyArg_ParseTuple(_args, "s#",
+ (char **)&arrow__in__, &arrow__in_len__))
+ return NULL;
+ if (arrow__in_len__ != sizeof(Cursor))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Cursor)");
+ goto arrow__error__;
+ }
+ SetQDGlobalsArrow(arrow__in__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ arrow__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_GetRegionBounds(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle region;
+ Rect bounds;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, ®ion))
+ return NULL;
+ GetRegionBounds(region,
+ &bounds);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &bounds);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Qd_IsRegionRectangular(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ RgnHandle region;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, ®ion))
+ return NULL;
+ _rv = IsRegionRectangular(region);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Qd_CreateNewPort(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CreateNewPort();
+ _res = Py_BuildValue("O&",
+ GrafObj_New, _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Qd_DisposePort(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ DisposePort(port);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Qd_SetQDError(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr err;
+ if (!PyArg_ParseTuple(_args, "h",
+ &err))
+ return NULL;
+ SetQDError(err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Qd_QDIsPortBuffered(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = QDIsPortBuffered(port);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_QDIsPortBufferDirty(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = QDIsPortBufferDirty(port);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_QDFlushPortBuffer(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ RgnHandle region;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ OptResObj_Convert, ®ion))
+ return NULL;
+ QDFlushPortBuffer(port,
+ region);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_TextFont(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short font;
+ if (!PyArg_ParseTuple(_args, "h",
+ &font))
+ return NULL;
+ TextFont(font);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_TextFace(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ StyleParameter face;
+ if (!PyArg_ParseTuple(_args, "h",
+ &face))
+ return NULL;
+ TextFace(face);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_TextMode(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short mode;
+ if (!PyArg_ParseTuple(_args, "h",
+ &mode))
+ return NULL;
+ TextMode(mode);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_TextSize(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short size;
+ if (!PyArg_ParseTuple(_args, "h",
+ &size))
+ return NULL;
+ TextSize(size);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SpaceExtra(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Fixed extra;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFixed, &extra))
+ return NULL;
+ SpaceExtra(extra);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_DrawChar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CharParameter ch;
+ if (!PyArg_ParseTuple(_args, "h",
+ &ch))
+ return NULL;
+ DrawChar(ch);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_DrawString(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Str255 s;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, s))
+ return NULL;
+ DrawString(s);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_MacDrawText(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ char *textBuf__in__;
+ int textBuf__len__;
+ int textBuf__in_len__;
+ short firstByte;
+ short byteCount;
+ if (!PyArg_ParseTuple(_args, "s#hh",
+ &textBuf__in__, &textBuf__in_len__,
+ &firstByte,
+ &byteCount))
+ return NULL;
+ MacDrawText(textBuf__in__,
+ firstByte,
+ byteCount);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ textBuf__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_CharWidth(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ CharParameter ch;
+ if (!PyArg_ParseTuple(_args, "h",
+ &ch))
+ return NULL;
+ _rv = CharWidth(ch);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_StringWidth(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ Str255 s;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, s))
+ return NULL;
+ _rv = StringWidth(s);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_TextWidth(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ char *textBuf__in__;
+ int textBuf__len__;
+ int textBuf__in_len__;
+ short firstByte;
+ short byteCount;
+ if (!PyArg_ParseTuple(_args, "s#hh",
+ &textBuf__in__, &textBuf__in_len__,
+ &firstByte,
+ &byteCount))
+ return NULL;
+ _rv = TextWidth(textBuf__in__,
+ firstByte,
+ byteCount);
+ _res = Py_BuildValue("h",
+ _rv);
+ textBuf__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_GetFontInfo(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ FontInfo info;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetFontInfo(&info);
+ _res = Py_BuildValue("O&",
+ QdFI_New, &info);
+ return _res;
+}
+
+static PyObject *Qd_CharExtra(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Fixed extra;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFixed, &extra))
+ return NULL;
+ CharExtra(extra);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetPort(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GrafPtr thePort;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &thePort))
+ return NULL;
+ SetPort(thePort);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_GetCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CursHandle _rv;
+ short cursorID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &cursorID))
+ return NULL;
+ _rv = GetCursor(cursorID);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qd_SetCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Cursor *crsr__in__;
+ int crsr__in_len__;
+ if (!PyArg_ParseTuple(_args, "s#",
+ (char **)&crsr__in__, &crsr__in_len__))
+ return NULL;
+ if (crsr__in_len__ != sizeof(Cursor))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Cursor)");
+ goto crsr__error__;
+ }
+ SetCursor(crsr__in__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ crsr__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_ShowCursor(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ShowCursor();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_LineTo(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short h;
+ short v;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &h,
+ &v))
+ return NULL;
+ LineTo(h,
+ v);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short left;
+ short top;
+ short right;
+ short bottom;
+ if (!PyArg_ParseTuple(_args, "hhhh",
+ &left,
+ &top,
+ &right,
+ &bottom))
+ return NULL;
+ SetRect(&r,
+ left,
+ top,
+ right,
+ bottom);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &r);
+ return _res;
+}
+
+static PyObject *Qd_OffsetRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short dh;
+ short dv;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetRect, &r,
+ &dh,
+ &dv))
+ return NULL;
+ OffsetRect(&r,
+ dh,
+ dv);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &r);
+ return _res;
+}
+
+static PyObject *Qd_InsetRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ short dh;
+ short dv;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetRect, &r,
+ &dh,
+ &dv))
+ return NULL;
+ InsetRect(&r,
+ dh,
+ dv);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &r);
+ return _res;
+}
+
+static PyObject *Qd_UnionRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect src1;
+ Rect src2;
+ Rect dstRect;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &src1,
+ PyMac_GetRect, &src2))
+ return NULL;
+ UnionRect(&src1,
+ &src2,
+ &dstRect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &dstRect);
+ return _res;
+}
+
+static PyObject *Qd_EqualRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Rect rect1;
+ Rect rect2;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &rect1,
+ PyMac_GetRect, &rect2))
+ return NULL;
+ _rv = EqualRect(&rect1,
+ &rect2);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_FrameRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &r))
+ return NULL;
+ FrameRect(&r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_InvertRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &r))
+ return NULL;
+ InvertRect(&r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_FillRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect r;
+ Pattern *pat__in__;
+ int pat__in_len__;
+ if (!PyArg_ParseTuple(_args, "O&s#",
+ PyMac_GetRect, &r,
+ (char **)&pat__in__, &pat__in_len__))
+ return NULL;
+ if (pat__in_len__ != sizeof(Pattern))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
+ goto pat__error__;
+ }
+ FillRect(&r,
+ pat__in__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ pat__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_CopyRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle srcRgn;
+ RgnHandle dstRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &srcRgn,
+ ResObj_Convert, &dstRgn))
+ return NULL;
+ CopyRgn(srcRgn,
+ dstRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_SetRectRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ short left;
+ short top;
+ short right;
+ short bottom;
+ if (!PyArg_ParseTuple(_args, "O&hhhh",
+ ResObj_Convert, &rgn,
+ &left,
+ &top,
+ &right,
+ &bottom))
+ return NULL;
+ SetRectRgn(rgn,
+ left,
+ top,
+ right,
+ bottom);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_OffsetRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ short dh;
+ short dv;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ ResObj_Convert, &rgn,
+ &dh,
+ &dv))
+ return NULL;
+ OffsetRgn(rgn,
+ dh,
+ dv);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_UnionRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle srcRgnA;
+ RgnHandle srcRgnB;
+ RgnHandle dstRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ ResObj_Convert, &srcRgnA,
+ ResObj_Convert, &srcRgnB,
+ ResObj_Convert, &dstRgn))
+ return NULL;
+ UnionRgn(srcRgnA,
+ srcRgnB,
+ dstRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_XorRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle srcRgnA;
+ RgnHandle srcRgnB;
+ RgnHandle dstRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ ResObj_Convert, &srcRgnA,
+ ResObj_Convert, &srcRgnB,
+ ResObj_Convert, &dstRgn))
+ return NULL;
+ XorRgn(srcRgnA,
+ srcRgnB,
+ dstRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_EqualRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ RgnHandle rgnA;
+ RgnHandle rgnB;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &rgnA,
+ ResObj_Convert, &rgnB))
+ return NULL;
+ _rv = EqualRgn(rgnA,
+ rgnB);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_FrameRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &rgn))
+ return NULL;
+ FrameRgn(rgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_PaintRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &rgn))
+ return NULL;
+ PaintRgn(rgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_InvertRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &rgn))
+ return NULL;
+ InvertRgn(rgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_FillRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle rgn;
+ Pattern *pat__in__;
+ int pat__in_len__;
+ if (!PyArg_ParseTuple(_args, "O&s#",
+ ResObj_Convert, &rgn,
+ (char **)&pat__in__, &pat__in_len__))
+ return NULL;
+ if (pat__in_len__ != sizeof(Pattern))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
+ goto pat__error__;
+ }
+ FillRgn(rgn,
+ pat__in__);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ pat__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_GetPixel(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ short h;
+ short v;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &h,
+ &v))
+ return NULL;
+ _rv = GetPixel(h,
+ v);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_PtInRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point pt;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &pt,
+ PyMac_GetRect, &r))
+ return NULL;
+ _rv = PtInRect(pt,
+ &r);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qd_DrawText(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ char *textBuf__in__;
+ int textBuf__len__;
+ int textBuf__in_len__;
+ short firstByte;
+ short byteCount;
+ if (!PyArg_ParseTuple(_args, "s#hh",
+ &textBuf__in__, &textBuf__in_len__,
+ &firstByte,
+ &byteCount))
+ return NULL;
+ DrawText(textBuf__in__,
+ firstByte,
+ byteCount);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ textBuf__error__: ;
+ return _res;
+}
+
+static PyObject *Qd_BitMap(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ BitMap *ptr;
+ PyObject *source;
+ Rect bounds;
+ int rowbytes;
+ char *data;
+
+ if ( !PyArg_ParseTuple(_args, "O!iO&", &PyString_Type, &source, &rowbytes, PyMac_GetRect,
+ &bounds) )
+ return NULL;
+ data = PyString_AsString(source);
+ if ((ptr=(BitMap *)malloc(sizeof(BitMap))) == NULL )
+ return PyErr_NoMemory();
+ ptr->baseAddr = (Ptr)data;
+ ptr->rowBytes = rowbytes;
+ ptr->bounds = bounds;
+ if ( (_res = BMObj_New(ptr)) == NULL ) {
+ free(ptr);
+ return NULL;
+ }
+ ((BitMapObject *)_res)->referred_object = source;
+ Py_INCREF(source);
+ ((BitMapObject *)_res)->referred_bitmap = ptr;
+ return _res;
+
+}
+
+static PyObject *Qd_RawBitMap(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ BitMap *ptr;
+ PyObject *source;
+
+ if ( !PyArg_ParseTuple(_args, "O!", &PyString_Type, &source) )
+ return NULL;
+ if ( PyString_Size(source) != sizeof(BitMap) && PyString_Size(source) != sizeof(PixMap) ) {
+ PyErr_BadArgument();
+ return NULL;
+ }
+ ptr = (BitMapPtr)PyString_AsString(source);
+ if ( (_res = BMObj_New(ptr)) == NULL ) {
+ return NULL;
+ }
+ ((BitMapObject *)_res)->referred_object = source;
+ Py_INCREF(source);
+ return _res;
+
+}
+
+static PyMethodDef Qd_methods[] = {
+ {"MacSetPort", (PyCFunction)Qd_MacSetPort, 1,
+ "(GrafPtr port) -> None"},
+ {"GetPort", (PyCFunction)Qd_GetPort, 1,
+ "() -> (GrafPtr port)"},
+ {"GrafDevice", (PyCFunction)Qd_GrafDevice, 1,
+ "(short device) -> None"},
+ {"SetPortBits", (PyCFunction)Qd_SetPortBits, 1,
+ "(BitMapPtr bm) -> None"},
+ {"PortSize", (PyCFunction)Qd_PortSize, 1,
+ "(short width, short height) -> None"},
+ {"MovePortTo", (PyCFunction)Qd_MovePortTo, 1,
+ "(short leftGlobal, short topGlobal) -> None"},
+ {"SetOrigin", (PyCFunction)Qd_SetOrigin, 1,
+ "(short h, short v) -> None"},
+ {"SetClip", (PyCFunction)Qd_SetClip, 1,
+ "(RgnHandle rgn) -> None"},
+ {"GetClip", (PyCFunction)Qd_GetClip, 1,
+ "(RgnHandle rgn) -> None"},
+ {"ClipRect", (PyCFunction)Qd_ClipRect, 1,
+ "(Rect r) -> None"},
+ {"BackPat", (PyCFunction)Qd_BackPat, 1,
+ "(Pattern pat) -> None"},
+ {"InitCursor", (PyCFunction)Qd_InitCursor, 1,
+ "() -> None"},
+ {"MacSetCursor", (PyCFunction)Qd_MacSetCursor, 1,
+ "(Cursor crsr) -> None"},
+ {"HideCursor", (PyCFunction)Qd_HideCursor, 1,
+ "() -> None"},
+ {"MacShowCursor", (PyCFunction)Qd_MacShowCursor, 1,
+ "() -> None"},
+ {"ObscureCursor", (PyCFunction)Qd_ObscureCursor, 1,
+ "() -> None"},
+ {"HidePen", (PyCFunction)Qd_HidePen, 1,
+ "() -> None"},
+ {"ShowPen", (PyCFunction)Qd_ShowPen, 1,
+ "() -> None"},
+ {"GetPen", (PyCFunction)Qd_GetPen, 1,
+ "() -> (Point pt)"},
+ {"GetPenState", (PyCFunction)Qd_GetPenState, 1,
+ "() -> (PenState pnState)"},
+ {"SetPenState", (PyCFunction)Qd_SetPenState, 1,
+ "(PenState pnState) -> None"},
+ {"PenSize", (PyCFunction)Qd_PenSize, 1,
+ "(short width, short height) -> None"},
+ {"PenMode", (PyCFunction)Qd_PenMode, 1,
+ "(short mode) -> None"},
+ {"PenPat", (PyCFunction)Qd_PenPat, 1,
+ "(Pattern pat) -> None"},
+ {"PenNormal", (PyCFunction)Qd_PenNormal, 1,
+ "() -> None"},
+ {"MoveTo", (PyCFunction)Qd_MoveTo, 1,
+ "(short h, short v) -> None"},
+ {"Move", (PyCFunction)Qd_Move, 1,
+ "(short dh, short dv) -> None"},
+ {"MacLineTo", (PyCFunction)Qd_MacLineTo, 1,
+ "(short h, short v) -> None"},
+ {"Line", (PyCFunction)Qd_Line, 1,
+ "(short dh, short dv) -> None"},
+ {"ForeColor", (PyCFunction)Qd_ForeColor, 1,
+ "(long color) -> None"},
+ {"BackColor", (PyCFunction)Qd_BackColor, 1,
+ "(long color) -> None"},
+ {"ColorBit", (PyCFunction)Qd_ColorBit, 1,
+ "(short whichBit) -> None"},
+ {"MacSetRect", (PyCFunction)Qd_MacSetRect, 1,
+ "(short left, short top, short right, short bottom) -> (Rect r)"},
+ {"MacOffsetRect", (PyCFunction)Qd_MacOffsetRect, 1,
+ "(Rect r, short dh, short dv) -> (Rect r)"},
+ {"MacInsetRect", (PyCFunction)Qd_MacInsetRect, 1,
+ "(Rect r, short dh, short dv) -> (Rect r)"},
+ {"SectRect", (PyCFunction)Qd_SectRect, 1,
+ "(Rect src1, Rect src2) -> (Boolean _rv, Rect dstRect)"},
+ {"MacUnionRect", (PyCFunction)Qd_MacUnionRect, 1,
+ "(Rect src1, Rect src2) -> (Rect dstRect)"},
+ {"MacEqualRect", (PyCFunction)Qd_MacEqualRect, 1,
+ "(Rect rect1, Rect rect2) -> (Boolean _rv)"},
+ {"EmptyRect", (PyCFunction)Qd_EmptyRect, 1,
+ "(Rect r) -> (Boolean _rv)"},
+ {"MacFrameRect", (PyCFunction)Qd_MacFrameRect, 1,
+ "(Rect r) -> None"},
+ {"PaintRect", (PyCFunction)Qd_PaintRect, 1,
+ "(Rect r) -> None"},
+ {"EraseRect", (PyCFunction)Qd_EraseRect, 1,
+ "(Rect r) -> None"},
+ {"MacInvertRect", (PyCFunction)Qd_MacInvertRect, 1,
+ "(Rect r) -> None"},
+ {"MacFillRect", (PyCFunction)Qd_MacFillRect, 1,
+ "(Rect r, Pattern pat) -> None"},
+ {"FrameOval", (PyCFunction)Qd_FrameOval, 1,
+ "(Rect r) -> None"},
+ {"PaintOval", (PyCFunction)Qd_PaintOval, 1,
+ "(Rect r) -> None"},
+ {"EraseOval", (PyCFunction)Qd_EraseOval, 1,
+ "(Rect r) -> None"},
+ {"InvertOval", (PyCFunction)Qd_InvertOval, 1,
+ "(Rect r) -> None"},
+ {"FillOval", (PyCFunction)Qd_FillOval, 1,
+ "(Rect r, Pattern pat) -> None"},
+ {"FrameRoundRect", (PyCFunction)Qd_FrameRoundRect, 1,
+ "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+ {"PaintRoundRect", (PyCFunction)Qd_PaintRoundRect, 1,
+ "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+ {"EraseRoundRect", (PyCFunction)Qd_EraseRoundRect, 1,
+ "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+ {"InvertRoundRect", (PyCFunction)Qd_InvertRoundRect, 1,
+ "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+ {"FillRoundRect", (PyCFunction)Qd_FillRoundRect, 1,
+ "(Rect r, short ovalWidth, short ovalHeight, Pattern pat) -> None"},
+ {"FrameArc", (PyCFunction)Qd_FrameArc, 1,
+ "(Rect r, short startAngle, short arcAngle) -> None"},
+ {"PaintArc", (PyCFunction)Qd_PaintArc, 1,
+ "(Rect r, short startAngle, short arcAngle) -> None"},
+ {"EraseArc", (PyCFunction)Qd_EraseArc, 1,
+ "(Rect r, short startAngle, short arcAngle) -> None"},
+ {"InvertArc", (PyCFunction)Qd_InvertArc, 1,
+ "(Rect r, short startAngle, short arcAngle) -> None"},
+ {"FillArc", (PyCFunction)Qd_FillArc, 1,
+ "(Rect r, short startAngle, short arcAngle, Pattern pat) -> None"},
+ {"NewRgn", (PyCFunction)Qd_NewRgn, 1,
+ "() -> (RgnHandle _rv)"},
+ {"OpenRgn", (PyCFunction)Qd_OpenRgn, 1,
+ "() -> None"},
+ {"CloseRgn", (PyCFunction)Qd_CloseRgn, 1,
+ "(RgnHandle dstRgn) -> None"},
+ {"BitMapToRegion", (PyCFunction)Qd_BitMapToRegion, 1,
+ "(RgnHandle region, BitMapPtr bMap) -> None"},
+ {"DisposeRgn", (PyCFunction)Qd_DisposeRgn, 1,
+ "(RgnHandle rgn) -> None"},
+ {"MacCopyRgn", (PyCFunction)Qd_MacCopyRgn, 1,
+ "(RgnHandle srcRgn, RgnHandle dstRgn) -> None"},
+ {"SetEmptyRgn", (PyCFunction)Qd_SetEmptyRgn, 1,
+ "(RgnHandle rgn) -> None"},
+ {"MacSetRectRgn", (PyCFunction)Qd_MacSetRectRgn, 1,
+ "(RgnHandle rgn, short left, short top, short right, short bottom) -> None"},
+ {"RectRgn", (PyCFunction)Qd_RectRgn, 1,
+ "(RgnHandle rgn, Rect r) -> None"},
+ {"MacOffsetRgn", (PyCFunction)Qd_MacOffsetRgn, 1,
+ "(RgnHandle rgn, short dh, short dv) -> None"},
+ {"InsetRgn", (PyCFunction)Qd_InsetRgn, 1,
+ "(RgnHandle rgn, short dh, short dv) -> None"},
+ {"SectRgn", (PyCFunction)Qd_SectRgn, 1,
+ "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+ {"MacUnionRgn", (PyCFunction)Qd_MacUnionRgn, 1,
+ "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+ {"DiffRgn", (PyCFunction)Qd_DiffRgn, 1,
+ "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+ {"MacXorRgn", (PyCFunction)Qd_MacXorRgn, 1,
+ "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+ {"RectInRgn", (PyCFunction)Qd_RectInRgn, 1,
+ "(Rect r, RgnHandle rgn) -> (Boolean _rv)"},
+ {"MacEqualRgn", (PyCFunction)Qd_MacEqualRgn, 1,
+ "(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)"},
+ {"EmptyRgn", (PyCFunction)Qd_EmptyRgn, 1,
+ "(RgnHandle rgn) -> (Boolean _rv)"},
+ {"MacFrameRgn", (PyCFunction)Qd_MacFrameRgn, 1,
+ "(RgnHandle rgn) -> None"},
+ {"MacPaintRgn", (PyCFunction)Qd_MacPaintRgn, 1,
+ "(RgnHandle rgn) -> None"},
+ {"EraseRgn", (PyCFunction)Qd_EraseRgn, 1,
+ "(RgnHandle rgn) -> None"},
+ {"MacInvertRgn", (PyCFunction)Qd_MacInvertRgn, 1,
+ "(RgnHandle rgn) -> None"},
+ {"MacFillRgn", (PyCFunction)Qd_MacFillRgn, 1,
+ "(RgnHandle rgn, Pattern pat) -> None"},
+ {"ScrollRect", (PyCFunction)Qd_ScrollRect, 1,
+ "(Rect r, short dh, short dv, RgnHandle updateRgn) -> None"},
+ {"CopyBits", (PyCFunction)Qd_CopyBits, 1,
+ "(BitMapPtr srcBits, BitMapPtr dstBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
+ {"CopyMask", (PyCFunction)Qd_CopyMask, 1,
+ "(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect) -> None"},
+ {"OpenPicture", (PyCFunction)Qd_OpenPicture, 1,
+ "(Rect picFrame) -> (PicHandle _rv)"},
+ {"PicComment", (PyCFunction)Qd_PicComment, 1,
+ "(short kind, short dataSize, Handle dataHandle) -> None"},
+ {"ClosePicture", (PyCFunction)Qd_ClosePicture, 1,
+ "() -> None"},
+ {"DrawPicture", (PyCFunction)Qd_DrawPicture, 1,
+ "(PicHandle myPicture, Rect dstRect) -> None"},
+ {"KillPicture", (PyCFunction)Qd_KillPicture, 1,
+ "(PicHandle myPicture) -> None"},
+ {"OpenPoly", (PyCFunction)Qd_OpenPoly, 1,
+ "() -> (PolyHandle _rv)"},
+ {"ClosePoly", (PyCFunction)Qd_ClosePoly, 1,
+ "() -> None"},
+ {"KillPoly", (PyCFunction)Qd_KillPoly, 1,
+ "(PolyHandle poly) -> None"},
+ {"OffsetPoly", (PyCFunction)Qd_OffsetPoly, 1,
+ "(PolyHandle poly, short dh, short dv) -> None"},
+ {"FramePoly", (PyCFunction)Qd_FramePoly, 1,
+ "(PolyHandle poly) -> None"},
+ {"PaintPoly", (PyCFunction)Qd_PaintPoly, 1,
+ "(PolyHandle poly) -> None"},
+ {"ErasePoly", (PyCFunction)Qd_ErasePoly, 1,
+ "(PolyHandle poly) -> None"},
+ {"InvertPoly", (PyCFunction)Qd_InvertPoly, 1,
+ "(PolyHandle poly) -> None"},
+ {"FillPoly", (PyCFunction)Qd_FillPoly, 1,
+ "(PolyHandle poly, Pattern pat) -> None"},
+ {"SetPt", (PyCFunction)Qd_SetPt, 1,
+ "(short h, short v) -> (Point pt)"},
+ {"LocalToGlobal", (PyCFunction)Qd_LocalToGlobal, 1,
+ "(Point pt) -> (Point pt)"},
+ {"GlobalToLocal", (PyCFunction)Qd_GlobalToLocal, 1,
+ "(Point pt) -> (Point pt)"},
+ {"Random", (PyCFunction)Qd_Random, 1,
+ "() -> (short _rv)"},
+ {"MacGetPixel", (PyCFunction)Qd_MacGetPixel, 1,
+ "(short h, short v) -> (Boolean _rv)"},
+ {"ScalePt", (PyCFunction)Qd_ScalePt, 1,
+ "(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)"},
+ {"MapPt", (PyCFunction)Qd_MapPt, 1,
+ "(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)"},
+ {"MapRect", (PyCFunction)Qd_MapRect, 1,
+ "(Rect r, Rect srcRect, Rect dstRect) -> (Rect r)"},
+ {"MapRgn", (PyCFunction)Qd_MapRgn, 1,
+ "(RgnHandle rgn, Rect srcRect, Rect dstRect) -> None"},
+ {"MapPoly", (PyCFunction)Qd_MapPoly, 1,
+ "(PolyHandle poly, Rect srcRect, Rect dstRect) -> None"},
+ {"StdBits", (PyCFunction)Qd_StdBits, 1,
+ "(BitMapPtr srcBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
+ {"AddPt", (PyCFunction)Qd_AddPt, 1,
+ "(Point src, Point dst) -> (Point dst)"},
+ {"EqualPt", (PyCFunction)Qd_EqualPt, 1,
+ "(Point pt1, Point pt2) -> (Boolean _rv)"},
+ {"MacPtInRect", (PyCFunction)Qd_MacPtInRect, 1,
+ "(Point pt, Rect r) -> (Boolean _rv)"},
+ {"Pt2Rect", (PyCFunction)Qd_Pt2Rect, 1,
+ "(Point pt1, Point pt2) -> (Rect dstRect)"},
+ {"PtToAngle", (PyCFunction)Qd_PtToAngle, 1,
+ "(Rect r, Point pt) -> (short angle)"},
+ {"SubPt", (PyCFunction)Qd_SubPt, 1,
+ "(Point src, Point dst) -> (Point dst)"},
+ {"PtInRgn", (PyCFunction)Qd_PtInRgn, 1,
+ "(Point pt, RgnHandle rgn) -> (Boolean _rv)"},
+ {"NewPixMap", (PyCFunction)Qd_NewPixMap, 1,
+ "() -> (PixMapHandle _rv)"},
+ {"DisposePixMap", (PyCFunction)Qd_DisposePixMap, 1,
+ "(PixMapHandle pm) -> None"},
+ {"CopyPixMap", (PyCFunction)Qd_CopyPixMap, 1,
+ "(PixMapHandle srcPM, PixMapHandle dstPM) -> None"},
+ {"NewPixPat", (PyCFunction)Qd_NewPixPat, 1,
+ "() -> (PixPatHandle _rv)"},
+ {"DisposePixPat", (PyCFunction)Qd_DisposePixPat, 1,
+ "(PixPatHandle pp) -> None"},
+ {"CopyPixPat", (PyCFunction)Qd_CopyPixPat, 1,
+ "(PixPatHandle srcPP, PixPatHandle dstPP) -> None"},
+ {"PenPixPat", (PyCFunction)Qd_PenPixPat, 1,
+ "(PixPatHandle pp) -> None"},
+ {"BackPixPat", (PyCFunction)Qd_BackPixPat, 1,
+ "(PixPatHandle pp) -> None"},
+ {"GetPixPat", (PyCFunction)Qd_GetPixPat, 1,
+ "(short patID) -> (PixPatHandle _rv)"},
+ {"MakeRGBPat", (PyCFunction)Qd_MakeRGBPat, 1,
+ "(PixPatHandle pp, RGBColor myColor) -> None"},
+ {"FillCRect", (PyCFunction)Qd_FillCRect, 1,
+ "(Rect r, PixPatHandle pp) -> None"},
+ {"FillCOval", (PyCFunction)Qd_FillCOval, 1,
+ "(Rect r, PixPatHandle pp) -> None"},
+ {"FillCRoundRect", (PyCFunction)Qd_FillCRoundRect, 1,
+ "(Rect r, short ovalWidth, short ovalHeight, PixPatHandle pp) -> None"},
+ {"FillCArc", (PyCFunction)Qd_FillCArc, 1,
+ "(Rect r, short startAngle, short arcAngle, PixPatHandle pp) -> None"},
+ {"FillCRgn", (PyCFunction)Qd_FillCRgn, 1,
+ "(RgnHandle rgn, PixPatHandle pp) -> None"},
+ {"FillCPoly", (PyCFunction)Qd_FillCPoly, 1,
+ "(PolyHandle poly, PixPatHandle pp) -> None"},
+ {"RGBForeColor", (PyCFunction)Qd_RGBForeColor, 1,
+ "(RGBColor color) -> None"},
+ {"RGBBackColor", (PyCFunction)Qd_RGBBackColor, 1,
+ "(RGBColor color) -> None"},
+ {"SetCPixel", (PyCFunction)Qd_SetCPixel, 1,
+ "(short h, short v, RGBColor cPix) -> None"},
+ {"SetPortPix", (PyCFunction)Qd_SetPortPix, 1,
+ "(PixMapHandle pm) -> None"},
+ {"GetCPixel", (PyCFunction)Qd_GetCPixel, 1,
+ "(short h, short v) -> (RGBColor cPix)"},
+ {"GetForeColor", (PyCFunction)Qd_GetForeColor, 1,
+ "() -> (RGBColor color)"},
+ {"GetBackColor", (PyCFunction)Qd_GetBackColor, 1,
+ "() -> (RGBColor color)"},
+ {"OpColor", (PyCFunction)Qd_OpColor, 1,
+ "(RGBColor color) -> None"},
+ {"HiliteColor", (PyCFunction)Qd_HiliteColor, 1,
+ "(RGBColor color) -> None"},
+ {"DisposeCTable", (PyCFunction)Qd_DisposeCTable, 1,
+ "(CTabHandle cTable) -> None"},
+ {"GetCTable", (PyCFunction)Qd_GetCTable, 1,
+ "(short ctID) -> (CTabHandle _rv)"},
+ {"GetCCursor", (PyCFunction)Qd_GetCCursor, 1,
+ "(short crsrID) -> (CCrsrHandle _rv)"},
+ {"SetCCursor", (PyCFunction)Qd_SetCCursor, 1,
+ "(CCrsrHandle cCrsr) -> None"},
+ {"AllocCursor", (PyCFunction)Qd_AllocCursor, 1,
+ "() -> None"},
+ {"DisposeCCursor", (PyCFunction)Qd_DisposeCCursor, 1,
+ "(CCrsrHandle cCrsr) -> None"},
+ {"GetMaxDevice", (PyCFunction)Qd_GetMaxDevice, 1,
+ "(Rect globalRect) -> (GDHandle _rv)"},
+ {"GetCTSeed", (PyCFunction)Qd_GetCTSeed, 1,
+ "() -> (long _rv)"},
+ {"GetDeviceList", (PyCFunction)Qd_GetDeviceList, 1,
+ "() -> (GDHandle _rv)"},
+ {"GetMainDevice", (PyCFunction)Qd_GetMainDevice, 1,
+ "() -> (GDHandle _rv)"},
+ {"GetNextDevice", (PyCFunction)Qd_GetNextDevice, 1,
+ "(GDHandle curDevice) -> (GDHandle _rv)"},
+ {"TestDeviceAttribute", (PyCFunction)Qd_TestDeviceAttribute, 1,
+ "(GDHandle gdh, short attribute) -> (Boolean _rv)"},
+ {"SetDeviceAttribute", (PyCFunction)Qd_SetDeviceAttribute, 1,
+ "(GDHandle gdh, short attribute, Boolean value) -> None"},
+ {"InitGDevice", (PyCFunction)Qd_InitGDevice, 1,
+ "(short qdRefNum, long mode, GDHandle gdh) -> None"},
+ {"NewGDevice", (PyCFunction)Qd_NewGDevice, 1,
+ "(short refNum, long mode) -> (GDHandle _rv)"},
+ {"DisposeGDevice", (PyCFunction)Qd_DisposeGDevice, 1,
+ "(GDHandle gdh) -> None"},
+ {"SetGDevice", (PyCFunction)Qd_SetGDevice, 1,
+ "(GDHandle gd) -> None"},
+ {"GetGDevice", (PyCFunction)Qd_GetGDevice, 1,
+ "() -> (GDHandle _rv)"},
+ {"Color2Index", (PyCFunction)Qd_Color2Index, 1,
+ "(RGBColor myColor) -> (long _rv)"},
+ {"Index2Color", (PyCFunction)Qd_Index2Color, 1,
+ "(long index) -> (RGBColor aColor)"},
+ {"InvertColor", (PyCFunction)Qd_InvertColor, 1,
+ "() -> (RGBColor myColor)"},
+ {"RealColor", (PyCFunction)Qd_RealColor, 1,
+ "(RGBColor color) -> (Boolean _rv)"},
+ {"GetSubTable", (PyCFunction)Qd_GetSubTable, 1,
+ "(CTabHandle myColors, short iTabRes, CTabHandle targetTbl) -> None"},
+ {"MakeITable", (PyCFunction)Qd_MakeITable, 1,
+ "(CTabHandle cTabH, ITabHandle iTabH, short res) -> None"},
+ {"SetClientID", (PyCFunction)Qd_SetClientID, 1,
+ "(short id) -> None"},
+ {"ProtectEntry", (PyCFunction)Qd_ProtectEntry, 1,
+ "(short index, Boolean protect) -> None"},
+ {"ReserveEntry", (PyCFunction)Qd_ReserveEntry, 1,
+ "(short index, Boolean reserve) -> None"},
+ {"QDError", (PyCFunction)Qd_QDError, 1,
+ "() -> (short _rv)"},
+ {"CopyDeepMask", (PyCFunction)Qd_CopyDeepMask, 1,
+ "(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
+ {"GetPattern", (PyCFunction)Qd_GetPattern, 1,
+ "(short patternID) -> (PatHandle _rv)"},
+ {"MacGetCursor", (PyCFunction)Qd_MacGetCursor, 1,
+ "(short cursorID) -> (CursHandle _rv)"},
+ {"GetPicture", (PyCFunction)Qd_GetPicture, 1,
+ "(short pictureID) -> (PicHandle _rv)"},
+ {"DeltaPoint", (PyCFunction)Qd_DeltaPoint, 1,
+ "(Point ptA, Point ptB) -> (long _rv)"},
+ {"ShieldCursor", (PyCFunction)Qd_ShieldCursor, 1,
+ "(Rect shieldRect, Point offsetPt) -> None"},
+ {"ScreenRes", (PyCFunction)Qd_ScreenRes, 1,
+ "() -> (short scrnHRes, short scrnVRes)"},
+ {"GetIndPattern", (PyCFunction)Qd_GetIndPattern, 1,
+ "(short patternListID, short index) -> (Pattern thePat)"},
+ {"SlopeFromAngle", (PyCFunction)Qd_SlopeFromAngle, 1,
+ "(short angle) -> (Fixed _rv)"},
+ {"AngleFromSlope", (PyCFunction)Qd_AngleFromSlope, 1,
+ "(Fixed slope) -> (short _rv)"},
+ {"GetPortPixMap", (PyCFunction)Qd_GetPortPixMap, 1,
+ "(CGrafPtr port) -> (PixMapHandle _rv)"},
+ {"GetPortBitMapForCopyBits", (PyCFunction)Qd_GetPortBitMapForCopyBits, 1,
+ "(CGrafPtr port) -> (const BitMap * _rv)"},
+ {"GetPortBounds", (PyCFunction)Qd_GetPortBounds, 1,
+ "(CGrafPtr port) -> (Rect rect)"},
+ {"GetPortForeColor", (PyCFunction)Qd_GetPortForeColor, 1,
+ "(CGrafPtr port) -> (RGBColor foreColor)"},
+ {"GetPortBackColor", (PyCFunction)Qd_GetPortBackColor, 1,
+ "(CGrafPtr port) -> (RGBColor backColor)"},
+ {"GetPortOpColor", (PyCFunction)Qd_GetPortOpColor, 1,
+ "(CGrafPtr port) -> (RGBColor opColor)"},
+ {"GetPortHiliteColor", (PyCFunction)Qd_GetPortHiliteColor, 1,
+ "(CGrafPtr port) -> (RGBColor hiliteColor)"},
+ {"GetPortTextFont", (PyCFunction)Qd_GetPortTextFont, 1,
+ "(CGrafPtr port) -> (short _rv)"},
+ {"GetPortTextFace", (PyCFunction)Qd_GetPortTextFace, 1,
+ "(CGrafPtr port) -> (Style _rv)"},
+ {"GetPortTextMode", (PyCFunction)Qd_GetPortTextMode, 1,
+ "(CGrafPtr port) -> (short _rv)"},
+ {"GetPortTextSize", (PyCFunction)Qd_GetPortTextSize, 1,
+ "(CGrafPtr port) -> (short _rv)"},
+ {"GetPortChExtra", (PyCFunction)Qd_GetPortChExtra, 1,
+ "(CGrafPtr port) -> (short _rv)"},
+ {"GetPortFracHPenLocation", (PyCFunction)Qd_GetPortFracHPenLocation, 1,
+ "(CGrafPtr port) -> (short _rv)"},
+ {"GetPortSpExtra", (PyCFunction)Qd_GetPortSpExtra, 1,
+ "(CGrafPtr port) -> (Fixed _rv)"},
+ {"GetPortPenVisibility", (PyCFunction)Qd_GetPortPenVisibility, 1,
+ "(CGrafPtr port) -> (short _rv)"},
+ {"GetPortVisibleRegion", (PyCFunction)Qd_GetPortVisibleRegion, 1,
+ "(CGrafPtr port, RgnHandle visRgn) -> (RgnHandle _rv)"},
+ {"GetPortClipRegion", (PyCFunction)Qd_GetPortClipRegion, 1,
+ "(CGrafPtr port, RgnHandle clipRgn) -> (RgnHandle _rv)"},
+ {"GetPortBackPixPat", (PyCFunction)Qd_GetPortBackPixPat, 1,
+ "(CGrafPtr port, PixPatHandle backPattern) -> (PixPatHandle _rv)"},
+ {"GetPortPenPixPat", (PyCFunction)Qd_GetPortPenPixPat, 1,
+ "(CGrafPtr port, PixPatHandle penPattern) -> (PixPatHandle _rv)"},
+ {"GetPortFillPixPat", (PyCFunction)Qd_GetPortFillPixPat, 1,
+ "(CGrafPtr port, PixPatHandle fillPattern) -> (PixPatHandle _rv)"},
+ {"GetPortPenSize", (PyCFunction)Qd_GetPortPenSize, 1,
+ "(CGrafPtr port, Point penSize) -> (Point penSize)"},
+ {"GetPortPenMode", (PyCFunction)Qd_GetPortPenMode, 1,
+ "(CGrafPtr port) -> (SInt32 _rv)"},
+ {"GetPortPenLocation", (PyCFunction)Qd_GetPortPenLocation, 1,
+ "(CGrafPtr port, Point penLocation) -> (Point penLocation)"},
+ {"IsPortRegionBeingDefined", (PyCFunction)Qd_IsPortRegionBeingDefined, 1,
+ "(CGrafPtr port) -> (Boolean _rv)"},
+ {"IsPortPictureBeingDefined", (PyCFunction)Qd_IsPortPictureBeingDefined, 1,
+ "(CGrafPtr port) -> (Boolean _rv)"},
+
+#if TARGET_API_MAC_CARBON
+ {"IsPortOffscreen", (PyCFunction)Qd_IsPortOffscreen, 1,
+ "(CGrafPtr port) -> (Boolean _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"IsPortColor", (PyCFunction)Qd_IsPortColor, 1,
+ "(CGrafPtr port) -> (Boolean _rv)"},
+#endif
+ {"SetPortBounds", (PyCFunction)Qd_SetPortBounds, 1,
+ "(CGrafPtr port, Rect rect) -> None"},
+ {"SetPortOpColor", (PyCFunction)Qd_SetPortOpColor, 1,
+ "(CGrafPtr port, RGBColor opColor) -> None"},
+ {"SetPortVisibleRegion", (PyCFunction)Qd_SetPortVisibleRegion, 1,
+ "(CGrafPtr port, RgnHandle visRgn) -> None"},
+ {"SetPortClipRegion", (PyCFunction)Qd_SetPortClipRegion, 1,
+ "(CGrafPtr port, RgnHandle clipRgn) -> None"},
+ {"SetPortPenPixPat", (PyCFunction)Qd_SetPortPenPixPat, 1,
+ "(CGrafPtr port, PixPatHandle penPattern) -> None"},
+ {"SetPortBackPixPat", (PyCFunction)Qd_SetPortBackPixPat, 1,
+ "(CGrafPtr port, PixPatHandle backPattern) -> None"},
+ {"SetPortPenSize", (PyCFunction)Qd_SetPortPenSize, 1,
+ "(CGrafPtr port, Point penSize) -> None"},
+ {"SetPortPenMode", (PyCFunction)Qd_SetPortPenMode, 1,
+ "(CGrafPtr port, SInt32 penMode) -> None"},
+ {"SetPortFracHPenLocation", (PyCFunction)Qd_SetPortFracHPenLocation, 1,
+ "(CGrafPtr port, short pnLocHFrac) -> None"},
+ {"GetPixBounds", (PyCFunction)Qd_GetPixBounds, 1,
+ "(PixMapHandle pixMap) -> (Rect bounds)"},
+ {"GetPixDepth", (PyCFunction)Qd_GetPixDepth, 1,
+ "(PixMapHandle pixMap) -> (short _rv)"},
+ {"GetQDGlobalsRandomSeed", (PyCFunction)Qd_GetQDGlobalsRandomSeed, 1,
+ "() -> (long _rv)"},
+ {"GetQDGlobalsScreenBits", (PyCFunction)Qd_GetQDGlobalsScreenBits, 1,
+ "() -> (BitMap screenBits)"},
+ {"GetQDGlobalsArrow", (PyCFunction)Qd_GetQDGlobalsArrow, 1,
+ "() -> (Cursor arrow)"},
+ {"GetQDGlobalsDarkGray", (PyCFunction)Qd_GetQDGlobalsDarkGray, 1,
+ "() -> (Pattern dkGray)"},
+ {"GetQDGlobalsLightGray", (PyCFunction)Qd_GetQDGlobalsLightGray, 1,
+ "() -> (Pattern ltGray)"},
+ {"GetQDGlobalsGray", (PyCFunction)Qd_GetQDGlobalsGray, 1,
+ "() -> (Pattern gray)"},
+ {"GetQDGlobalsBlack", (PyCFunction)Qd_GetQDGlobalsBlack, 1,
+ "() -> (Pattern black)"},
+ {"GetQDGlobalsWhite", (PyCFunction)Qd_GetQDGlobalsWhite, 1,
+ "() -> (Pattern white)"},
+ {"GetQDGlobalsThePort", (PyCFunction)Qd_GetQDGlobalsThePort, 1,
+ "() -> (CGrafPtr _rv)"},
+ {"SetQDGlobalsRandomSeed", (PyCFunction)Qd_SetQDGlobalsRandomSeed, 1,
+ "(long randomSeed) -> None"},
+ {"SetQDGlobalsArrow", (PyCFunction)Qd_SetQDGlobalsArrow, 1,
+ "(Cursor arrow) -> None"},
+ {"GetRegionBounds", (PyCFunction)Qd_GetRegionBounds, 1,
+ "(RgnHandle region) -> (Rect bounds)"},
+
+#if TARGET_API_MAC_CARBON
+ {"IsRegionRectangular", (PyCFunction)Qd_IsRegionRectangular, 1,
+ "(RgnHandle region) -> (Boolean _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"CreateNewPort", (PyCFunction)Qd_CreateNewPort, 1,
+ "() -> (CGrafPtr _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"DisposePort", (PyCFunction)Qd_DisposePort, 1,
+ "(CGrafPtr port) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"SetQDError", (PyCFunction)Qd_SetQDError, 1,
+ "(OSErr err) -> None"},
+#endif
+ {"QDIsPortBuffered", (PyCFunction)Qd_QDIsPortBuffered, 1,
+ "(CGrafPtr port) -> (Boolean _rv)"},
+ {"QDIsPortBufferDirty", (PyCFunction)Qd_QDIsPortBufferDirty, 1,
+ "(CGrafPtr port) -> (Boolean _rv)"},
+ {"QDFlushPortBuffer", (PyCFunction)Qd_QDFlushPortBuffer, 1,
+ "(CGrafPtr port, RgnHandle region) -> None"},
+ {"TextFont", (PyCFunction)Qd_TextFont, 1,
+ "(short font) -> None"},
+ {"TextFace", (PyCFunction)Qd_TextFace, 1,
+ "(StyleParameter face) -> None"},
+ {"TextMode", (PyCFunction)Qd_TextMode, 1,
+ "(short mode) -> None"},
+ {"TextSize", (PyCFunction)Qd_TextSize, 1,
+ "(short size) -> None"},
+ {"SpaceExtra", (PyCFunction)Qd_SpaceExtra, 1,
+ "(Fixed extra) -> None"},
+ {"DrawChar", (PyCFunction)Qd_DrawChar, 1,
+ "(CharParameter ch) -> None"},
+ {"DrawString", (PyCFunction)Qd_DrawString, 1,
+ "(Str255 s) -> None"},
+ {"MacDrawText", (PyCFunction)Qd_MacDrawText, 1,
+ "(Buffer textBuf, short firstByte, short byteCount) -> None"},
+ {"CharWidth", (PyCFunction)Qd_CharWidth, 1,
+ "(CharParameter ch) -> (short _rv)"},
+ {"StringWidth", (PyCFunction)Qd_StringWidth, 1,
+ "(Str255 s) -> (short _rv)"},
+ {"TextWidth", (PyCFunction)Qd_TextWidth, 1,
+ "(Buffer textBuf, short firstByte, short byteCount) -> (short _rv)"},
+ {"GetFontInfo", (PyCFunction)Qd_GetFontInfo, 1,
+ "() -> (FontInfo info)"},
+ {"CharExtra", (PyCFunction)Qd_CharExtra, 1,
+ "(Fixed extra) -> None"},
+ {"SetPort", (PyCFunction)Qd_SetPort, 1,
+ "(GrafPtr thePort) -> None"},
+ {"GetCursor", (PyCFunction)Qd_GetCursor, 1,
+ "(short cursorID) -> (CursHandle _rv)"},
+ {"SetCursor", (PyCFunction)Qd_SetCursor, 1,
+ "(Cursor crsr) -> None"},
+ {"ShowCursor", (PyCFunction)Qd_ShowCursor, 1,
+ "() -> None"},
+ {"LineTo", (PyCFunction)Qd_LineTo, 1,
+ "(short h, short v) -> None"},
+ {"SetRect", (PyCFunction)Qd_SetRect, 1,
+ "(short left, short top, short right, short bottom) -> (Rect r)"},
+ {"OffsetRect", (PyCFunction)Qd_OffsetRect, 1,
+ "(Rect r, short dh, short dv) -> (Rect r)"},
+ {"InsetRect", (PyCFunction)Qd_InsetRect, 1,
+ "(Rect r, short dh, short dv) -> (Rect r)"},
+ {"UnionRect", (PyCFunction)Qd_UnionRect, 1,
+ "(Rect src1, Rect src2) -> (Rect dstRect)"},
+ {"EqualRect", (PyCFunction)Qd_EqualRect, 1,
+ "(Rect rect1, Rect rect2) -> (Boolean _rv)"},
+ {"FrameRect", (PyCFunction)Qd_FrameRect, 1,
+ "(Rect r) -> None"},
+ {"InvertRect", (PyCFunction)Qd_InvertRect, 1,
+ "(Rect r) -> None"},
+ {"FillRect", (PyCFunction)Qd_FillRect, 1,
+ "(Rect r, Pattern pat) -> None"},
+ {"CopyRgn", (PyCFunction)Qd_CopyRgn, 1,
+ "(RgnHandle srcRgn, RgnHandle dstRgn) -> None"},
+ {"SetRectRgn", (PyCFunction)Qd_SetRectRgn, 1,
+ "(RgnHandle rgn, short left, short top, short right, short bottom) -> None"},
+ {"OffsetRgn", (PyCFunction)Qd_OffsetRgn, 1,
+ "(RgnHandle rgn, short dh, short dv) -> None"},
+ {"UnionRgn", (PyCFunction)Qd_UnionRgn, 1,
+ "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+ {"XorRgn", (PyCFunction)Qd_XorRgn, 1,
+ "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+ {"EqualRgn", (PyCFunction)Qd_EqualRgn, 1,
+ "(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)"},
+ {"FrameRgn", (PyCFunction)Qd_FrameRgn, 1,
+ "(RgnHandle rgn) -> None"},
+ {"PaintRgn", (PyCFunction)Qd_PaintRgn, 1,
+ "(RgnHandle rgn) -> None"},
+ {"InvertRgn", (PyCFunction)Qd_InvertRgn, 1,
+ "(RgnHandle rgn) -> None"},
+ {"FillRgn", (PyCFunction)Qd_FillRgn, 1,
+ "(RgnHandle rgn, Pattern pat) -> None"},
+ {"GetPixel", (PyCFunction)Qd_GetPixel, 1,
+ "(short h, short v) -> (Boolean _rv)"},
+ {"PtInRect", (PyCFunction)Qd_PtInRect, 1,
+ "(Point pt, Rect r) -> (Boolean _rv)"},
+ {"DrawText", (PyCFunction)Qd_DrawText, 1,
+ "(Buffer textBuf, short firstByte, short byteCount) -> None"},
+ {"BitMap", (PyCFunction)Qd_BitMap, 1,
+ "Take (string, int, Rect) argument and create BitMap"},
+ {"RawBitMap", (PyCFunction)Qd_RawBitMap, 1,
+ "Take string BitMap and turn into BitMap object"},
+ {NULL, NULL, 0}
+};
+
+
+
+/* Like BMObj_New, but the original bitmap data structure is copied (and
+** released when the object is released)
+*/
+PyObject *BMObj_NewCopied(BitMapPtr itself)
+{
+ BitMapObject *it;
+ BitMapPtr itself_copy;
+
+ if ((itself_copy=(BitMapPtr)malloc(sizeof(BitMap))) == NULL)
+ return PyErr_NoMemory();
+ *itself_copy = *itself;
+ it = (BitMapObject *)BMObj_New(itself_copy);
+ it->referred_bitmap = itself_copy;
+ return (PyObject *)it;
+}
+
+
+
+void init_Qd(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(BitMapPtr, BMObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(BitMapPtr, BMObj_Convert);
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(GrafPtr, GrafObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(GrafPtr, GrafObj_Convert);
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(RGBColorPtr, QdRGB_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(RGBColor, QdRGB_Convert);
+
+
+ m = Py_InitModule("_Qd", Qd_methods);
+ d = PyModule_GetDict(m);
+ Qd_Error = PyMac_GetOSErrException();
+ if (Qd_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Qd_Error) != 0)
+ return;
+ GrafPort_Type.ob_type = &PyType_Type;
+ Py_INCREF(&GrafPort_Type);
+ if (PyDict_SetItemString(d, "GrafPortType", (PyObject *)&GrafPort_Type) != 0)
+ Py_FatalError("can't initialize GrafPortType");
+ BitMap_Type.ob_type = &PyType_Type;
+ Py_INCREF(&BitMap_Type);
+ if (PyDict_SetItemString(d, "BitMapType", (PyObject *)&BitMap_Type) != 0)
+ Py_FatalError("can't initialize BitMapType");
+ QDGlobalsAccess_Type.ob_type = &PyType_Type;
+ Py_INCREF(&QDGlobalsAccess_Type);
+ if (PyDict_SetItemString(d, "QDGlobalsAccessType", (PyObject *)&QDGlobalsAccess_Type) != 0)
+ Py_FatalError("can't initialize QDGlobalsAccessType");
+
+ {
+ PyObject *o;
+
+ o = QDGA_New();
+ if (o == NULL || PyDict_SetItemString(d, "qd", o) != 0)
+ return;
+ }
+
+
+}
+
+/* ========================= End module _Qd ========================= */
+
--- /dev/null
+
+/* ========================= Module _Qdoffs ========================= */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <QDOffscreen.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+extern PyObject *_GWorldObj_New(GWorldPtr);
+extern int _GWorldObj_Convert(PyObject *, GWorldPtr *);
+
+#define GWorldObj_New _GWorldObj_New
+#define GWorldObj_Convert _GWorldObj_Convert
+#endif
+
+#define as_GrafPtr(gworld) ((GrafPtr)(gworld))
+
+
+static PyObject *Qdoffs_Error;
+
+/* ----------------------- Object type GWorld ----------------------- */
+
+PyTypeObject GWorld_Type;
+
+#define GWorldObj_Check(x) ((x)->ob_type == &GWorld_Type)
+
+typedef struct GWorldObject {
+ PyObject_HEAD
+ GWorldPtr ob_itself;
+} GWorldObject;
+
+PyObject *GWorldObj_New(GWorldPtr itself)
+{
+ GWorldObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(GWorldObject, &GWorld_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+GWorldObj_Convert(PyObject *v, GWorldPtr *p_itself)
+{
+ if (!GWorldObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "GWorld required");
+ return 0;
+ }
+ *p_itself = ((GWorldObject *)v)->ob_itself;
+ return 1;
+}
+
+static void GWorldObj_dealloc(GWorldObject *self)
+{
+ DisposeGWorld(self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *GWorldObj_GetGWorldDevice(GWorldObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetGWorldDevice(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *GWorldObj_GetGWorldPixMap(GWorldObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetGWorldPixMap(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *GWorldObj_as_GrafPtr(GWorldObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GrafPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = as_GrafPtr(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ GrafObj_New, _rv);
+ return _res;
+}
+
+static PyMethodDef GWorldObj_methods[] = {
+ {"GetGWorldDevice", (PyCFunction)GWorldObj_GetGWorldDevice, 1,
+ "() -> (GDHandle _rv)"},
+ {"GetGWorldPixMap", (PyCFunction)GWorldObj_GetGWorldPixMap, 1,
+ "() -> (PixMapHandle _rv)"},
+ {"as_GrafPtr", (PyCFunction)GWorldObj_as_GrafPtr, 1,
+ "() -> (GrafPtr _rv)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain GWorldObj_chain = { GWorldObj_methods, NULL };
+
+static PyObject *GWorldObj_getattr(GWorldObject *self, char *name)
+{
+ return Py_FindMethodInChain(&GWorldObj_chain, (PyObject *)self, name);
+}
+
+#define GWorldObj_setattr NULL
+
+#define GWorldObj_compare NULL
+
+#define GWorldObj_repr NULL
+
+#define GWorldObj_hash NULL
+
+PyTypeObject GWorld_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "GWorld", /*tp_name*/
+ sizeof(GWorldObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) GWorldObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) GWorldObj_getattr, /*tp_getattr*/
+ (setattrfunc) GWorldObj_setattr, /*tp_setattr*/
+ (cmpfunc) GWorldObj_compare, /*tp_compare*/
+ (reprfunc) GWorldObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) GWorldObj_hash, /*tp_hash*/
+};
+
+/* --------------------- End object type GWorld --------------------- */
+
+
+static PyObject *Qdoffs_NewGWorld(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ QDErr _err;
+ GWorldPtr offscreenGWorld;
+ short PixelDepth;
+ Rect boundsRect;
+ CTabHandle cTable;
+ GDHandle aGDevice;
+ GWorldFlags flags;
+ if (!PyArg_ParseTuple(_args, "hO&O&O&l",
+ &PixelDepth,
+ PyMac_GetRect, &boundsRect,
+ OptResObj_Convert, &cTable,
+ OptResObj_Convert, &aGDevice,
+ &flags))
+ return NULL;
+ _err = NewGWorld(&offscreenGWorld,
+ PixelDepth,
+ &boundsRect,
+ cTable,
+ aGDevice,
+ flags);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ GWorldObj_New, offscreenGWorld);
+ return _res;
+}
+
+static PyObject *Qdoffs_LockPixels(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ PixMapHandle pm;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pm))
+ return NULL;
+ _rv = LockPixels(pm);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qdoffs_UnlockPixels(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle pm;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pm))
+ return NULL;
+ UnlockPixels(pm);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qdoffs_UpdateGWorld(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GWorldFlags _rv;
+ GWorldPtr offscreenGWorld;
+ short pixelDepth;
+ Rect boundsRect;
+ CTabHandle cTable;
+ GDHandle aGDevice;
+ GWorldFlags flags;
+ if (!PyArg_ParseTuple(_args, "hO&O&O&l",
+ &pixelDepth,
+ PyMac_GetRect, &boundsRect,
+ OptResObj_Convert, &cTable,
+ OptResObj_Convert, &aGDevice,
+ &flags))
+ return NULL;
+ _rv = UpdateGWorld(&offscreenGWorld,
+ pixelDepth,
+ &boundsRect,
+ cTable,
+ aGDevice,
+ flags);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ GWorldObj_New, offscreenGWorld);
+ return _res;
+}
+
+static PyObject *Qdoffs_GetGWorld(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ GDHandle gdh;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetGWorld(&port,
+ &gdh);
+ _res = Py_BuildValue("O&O&",
+ GrafObj_New, port,
+ ResObj_New, gdh);
+ return _res;
+}
+
+static PyObject *Qdoffs_SetGWorld(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ GDHandle gdh;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ OptResObj_Convert, &gdh))
+ return NULL;
+ SetGWorld(port,
+ gdh);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qdoffs_CTabChanged(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CTabHandle ctab;
+ if (!PyArg_ParseTuple(_args, "O&",
+ OptResObj_Convert, &ctab))
+ return NULL;
+ CTabChanged(ctab);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qdoffs_PixPatChanged(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixPatHandle ppat;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &ppat))
+ return NULL;
+ PixPatChanged(ppat);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qdoffs_PortChanged(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ PortChanged(port);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qdoffs_GDeviceChanged(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GDHandle gdh;
+ if (!PyArg_ParseTuple(_args, "O&",
+ OptResObj_Convert, &gdh))
+ return NULL;
+ GDeviceChanged(gdh);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qdoffs_AllowPurgePixels(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle pm;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pm))
+ return NULL;
+ AllowPurgePixels(pm);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qdoffs_NoPurgePixels(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle pm;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pm))
+ return NULL;
+ NoPurgePixels(pm);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qdoffs_GetPixelsState(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GWorldFlags _rv;
+ PixMapHandle pm;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pm))
+ return NULL;
+ _rv = GetPixelsState(pm);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qdoffs_SetPixelsState(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle pm;
+ GWorldFlags state;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ ResObj_Convert, &pm,
+ &state))
+ return NULL;
+ SetPixelsState(pm,
+ state);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qdoffs_GetPixRowBytes(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ PixMapHandle pm;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pm))
+ return NULL;
+ _rv = GetPixRowBytes(pm);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qdoffs_NewScreenBuffer(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ QDErr _err;
+ Rect globalRect;
+ Boolean purgeable;
+ GDHandle gdh;
+ PixMapHandle offscreenPixMap;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ PyMac_GetRect, &globalRect,
+ &purgeable))
+ return NULL;
+ _err = NewScreenBuffer(&globalRect,
+ purgeable,
+ &gdh,
+ &offscreenPixMap);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&",
+ ResObj_New, gdh,
+ ResObj_New, offscreenPixMap);
+ return _res;
+}
+
+static PyObject *Qdoffs_DisposeScreenBuffer(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle offscreenPixMap;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &offscreenPixMap))
+ return NULL;
+ DisposeScreenBuffer(offscreenPixMap);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qdoffs_QDDone(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ GrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = QDDone(port);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qdoffs_OffscreenVersion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = OffscreenVersion();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qdoffs_NewTempScreenBuffer(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ QDErr _err;
+ Rect globalRect;
+ Boolean purgeable;
+ GDHandle gdh;
+ PixMapHandle offscreenPixMap;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ PyMac_GetRect, &globalRect,
+ &purgeable))
+ return NULL;
+ _err = NewTempScreenBuffer(&globalRect,
+ purgeable,
+ &gdh,
+ &offscreenPixMap);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&",
+ ResObj_New, gdh,
+ ResObj_New, offscreenPixMap);
+ return _res;
+}
+
+static PyObject *Qdoffs_PixMap32Bit(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ PixMapHandle pmHandle;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pmHandle))
+ return NULL;
+ _rv = PixMap32Bit(pmHandle);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qdoffs_GetPixMapBytes(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ PixMapHandle pm;
+ int from, length;
+ char *cp;
+
+ if ( !PyArg_ParseTuple(_args, "O&ii", ResObj_Convert, &pm, &from, &length) )
+ return NULL;
+ cp = GetPixBaseAddr(pm)+from;
+ return PyString_FromStringAndSize(cp, length);
+
+}
+
+static PyObject *Qdoffs_PutPixMapBytes(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ PixMapHandle pm;
+ int from, length;
+ char *cp, *icp;
+
+ if ( !PyArg_ParseTuple(_args, "O&is#", ResObj_Convert, &pm, &from, &icp, &length) )
+ return NULL;
+ cp = GetPixBaseAddr(pm)+from;
+ memcpy(cp, icp, length);
+ Py_INCREF(Py_None);
+ return Py_None;
+
+}
+
+static PyMethodDef Qdoffs_methods[] = {
+ {"NewGWorld", (PyCFunction)Qdoffs_NewGWorld, 1,
+ "(short PixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldPtr offscreenGWorld)"},
+ {"LockPixels", (PyCFunction)Qdoffs_LockPixels, 1,
+ "(PixMapHandle pm) -> (Boolean _rv)"},
+ {"UnlockPixels", (PyCFunction)Qdoffs_UnlockPixels, 1,
+ "(PixMapHandle pm) -> None"},
+ {"UpdateGWorld", (PyCFunction)Qdoffs_UpdateGWorld, 1,
+ "(short pixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldFlags _rv, GWorldPtr offscreenGWorld)"},
+ {"GetGWorld", (PyCFunction)Qdoffs_GetGWorld, 1,
+ "() -> (CGrafPtr port, GDHandle gdh)"},
+ {"SetGWorld", (PyCFunction)Qdoffs_SetGWorld, 1,
+ "(CGrafPtr port, GDHandle gdh) -> None"},
+ {"CTabChanged", (PyCFunction)Qdoffs_CTabChanged, 1,
+ "(CTabHandle ctab) -> None"},
+ {"PixPatChanged", (PyCFunction)Qdoffs_PixPatChanged, 1,
+ "(PixPatHandle ppat) -> None"},
+ {"PortChanged", (PyCFunction)Qdoffs_PortChanged, 1,
+ "(GrafPtr port) -> None"},
+ {"GDeviceChanged", (PyCFunction)Qdoffs_GDeviceChanged, 1,
+ "(GDHandle gdh) -> None"},
+ {"AllowPurgePixels", (PyCFunction)Qdoffs_AllowPurgePixels, 1,
+ "(PixMapHandle pm) -> None"},
+ {"NoPurgePixels", (PyCFunction)Qdoffs_NoPurgePixels, 1,
+ "(PixMapHandle pm) -> None"},
+ {"GetPixelsState", (PyCFunction)Qdoffs_GetPixelsState, 1,
+ "(PixMapHandle pm) -> (GWorldFlags _rv)"},
+ {"SetPixelsState", (PyCFunction)Qdoffs_SetPixelsState, 1,
+ "(PixMapHandle pm, GWorldFlags state) -> None"},
+ {"GetPixRowBytes", (PyCFunction)Qdoffs_GetPixRowBytes, 1,
+ "(PixMapHandle pm) -> (long _rv)"},
+ {"NewScreenBuffer", (PyCFunction)Qdoffs_NewScreenBuffer, 1,
+ "(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)"},
+ {"DisposeScreenBuffer", (PyCFunction)Qdoffs_DisposeScreenBuffer, 1,
+ "(PixMapHandle offscreenPixMap) -> None"},
+ {"QDDone", (PyCFunction)Qdoffs_QDDone, 1,
+ "(GrafPtr port) -> (Boolean _rv)"},
+ {"OffscreenVersion", (PyCFunction)Qdoffs_OffscreenVersion, 1,
+ "() -> (long _rv)"},
+ {"NewTempScreenBuffer", (PyCFunction)Qdoffs_NewTempScreenBuffer, 1,
+ "(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)"},
+ {"PixMap32Bit", (PyCFunction)Qdoffs_PixMap32Bit, 1,
+ "(PixMapHandle pmHandle) -> (Boolean _rv)"},
+ {"GetPixMapBytes", (PyCFunction)Qdoffs_GetPixMapBytes, 1,
+ "(pixmap, int start, int size) -> string. Return bytes from the pixmap"},
+ {"PutPixMapBytes", (PyCFunction)Qdoffs_PutPixMapBytes, 1,
+ "(pixmap, int start, string data). Store bytes into the pixmap"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_Qdoffs(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(GWorldPtr, GWorldObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(GWorldPtr, GWorldObj_Convert);
+
+
+ m = Py_InitModule("_Qdoffs", Qdoffs_methods);
+ d = PyModule_GetDict(m);
+ Qdoffs_Error = PyMac_GetOSErrException();
+ if (Qdoffs_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Qdoffs_Error) != 0)
+ return;
+ GWorld_Type.ob_type = &PyType_Type;
+ Py_INCREF(&GWorld_Type);
+ if (PyDict_SetItemString(d, "GWorldType", (PyObject *)&GWorld_Type) != 0)
+ Py_FatalError("can't initialize GWorldType");
+}
+
+/* ======================= End module _Qdoffs ======================= */
+
--- /dev/null
+
+/* =========================== Module _Qt =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Movies.h>
+#else
+/* #include <Carbon/Carbon.h> */
+#include <QuickTime/QuickTime.h>
+#endif
+
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+extern PyObject *_TrackObj_New(Track);
+extern int _TrackObj_Convert(PyObject *, Track *);
+extern PyObject *_MovieObj_New(Movie);
+extern int _MovieObj_Convert(PyObject *, Movie *);
+extern PyObject *_MovieCtlObj_New(MovieController);
+extern int _MovieCtlObj_Convert(PyObject *, MovieController *);
+extern PyObject *_TimeBaseObj_New(TimeBase);
+extern int _TimeBaseObj_Convert(PyObject *, TimeBase *);
+extern PyObject *_UserDataObj_New(UserData);
+extern int _UserDataObj_Convert(PyObject *, UserData *);
+extern PyObject *_MediaObj_New(Media);
+extern int _MediaObj_Convert(PyObject *, Media *);
+
+#define TrackObj_New _TrackObj_New
+#define TrackObj_Convert _TrackObj_Convert
+#define MovieObj_New _MovieObj_New
+#define MovieObj_Convert _MovieObj_Convert
+#define MovieCtlObj_New _MovieCtlObj_New
+#define MovieCtlObj_Convert _MovieCtlObj_Convert
+#define TimeBaseObj_New _TimeBaseObj_New
+#define TimeBaseObj_Convert _TimeBaseObj_Convert
+#define UserDataObj_New _UserDataObj_New
+#define UserDataObj_Convert _UserDataObj_Convert
+#define MediaObj_New _MediaObj_New
+#define MediaObj_Convert _MediaObj_Convert
+#endif
+
+/* Macro to allow us to GetNextInterestingTime without duration */
+#define GetMediaNextInterestingTimeOnly(media, flags, time, rate, rv) GetMediaNextInterestingTime(media, flags, time, rate, rv, NULL)
+
+/*
+** Parse/generate time records
+*/
+static PyObject *
+QtTimeRecord_New(TimeRecord *itself)
+{
+ if (itself->base)
+ return Py_BuildValue("O&lO&", PyMac_Buildwide, &itself->value, itself->scale,
+ TimeBaseObj_New, itself->base);
+ else
+ return Py_BuildValue("O&lO", PyMac_Buildwide, &itself->value, itself->scale,
+ Py_None);
+}
+
+static int
+QtTimeRecord_Convert(PyObject *v, TimeRecord *p_itself)
+{
+ PyObject *base = NULL;
+ if( !PyArg_ParseTuple(v, "O&l|O", PyMac_Getwide, &p_itself->value, &p_itself->scale,
+ &base) )
+ return 0;
+ if ( base == NULL || base == Py_None )
+ p_itself->base = NULL;
+ else
+ if ( !TimeBaseObj_Convert(base, &p_itself->base) )
+ return 0;
+ return 1;
+}
+
+
+
+
+static PyObject *Qt_Error;
+
+/* ------------------ Object type MovieController ------------------- */
+
+PyTypeObject MovieController_Type;
+
+#define MovieCtlObj_Check(x) ((x)->ob_type == &MovieController_Type)
+
+typedef struct MovieControllerObject {
+ PyObject_HEAD
+ MovieController ob_itself;
+} MovieControllerObject;
+
+PyObject *MovieCtlObj_New(MovieController itself)
+{
+ MovieControllerObject *it;
+ if (itself == NULL) {
+ PyErr_SetString(Qt_Error,"Cannot create null MovieController");
+ return NULL;
+ }
+ it = PyObject_NEW(MovieControllerObject, &MovieController_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+MovieCtlObj_Convert(PyObject *v, MovieController *p_itself)
+{
+ if (!MovieCtlObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "MovieController required");
+ return 0;
+ }
+ *p_itself = ((MovieControllerObject *)v)->ob_itself;
+ return 1;
+}
+
+static void MovieCtlObj_dealloc(MovieControllerObject *self)
+{
+ DisposeMovieController(self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *MovieCtlObj_MCSetMovie(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Movie theMovie;
+ WindowPtr movieWindow;
+ Point where;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ MovieObj_Convert, &theMovie,
+ WinObj_Convert, &movieWindow,
+ PyMac_GetPoint, &where))
+ return NULL;
+ _rv = MCSetMovie(_self->ob_itself,
+ theMovie,
+ movieWindow,
+ where);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCGetIndMovie(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Movie _rv;
+ short index;
+ if (!PyArg_ParseTuple(_args, "h",
+ &index))
+ return NULL;
+ _rv = MCGetIndMovie(_self->ob_itself,
+ index);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCRemoveAllMovies(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCRemoveAllMovies(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCRemoveAMovie(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Movie m;
+ if (!PyArg_ParseTuple(_args, "O&",
+ MovieObj_Convert, &m))
+ return NULL;
+ _rv = MCRemoveAMovie(_self->ob_itself,
+ m);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCRemoveMovie(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCRemoveMovie(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCIsPlayerEvent(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ EventRecord e;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &e))
+ return NULL;
+ _rv = MCIsPlayerEvent(_self->ob_itself,
+ &e);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCDoAction(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ short action;
+ void * params;
+ if (!PyArg_ParseTuple(_args, "hs",
+ &action,
+ ¶ms))
+ return NULL;
+ _rv = MCDoAction(_self->ob_itself,
+ action,
+ params);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCSetControllerAttached(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Boolean attach;
+ if (!PyArg_ParseTuple(_args, "b",
+ &attach))
+ return NULL;
+ _rv = MCSetControllerAttached(_self->ob_itself,
+ attach);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCIsControllerAttached(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCIsControllerAttached(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCSetControllerPort(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ CGrafPtr gp;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &gp))
+ return NULL;
+ _rv = MCSetControllerPort(_self->ob_itself,
+ gp);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCGetControllerPort(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCGetControllerPort(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ GrafObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCSetVisible(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Boolean visible;
+ if (!PyArg_ParseTuple(_args, "b",
+ &visible))
+ return NULL;
+ _rv = MCSetVisible(_self->ob_itself,
+ visible);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCGetVisible(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCGetVisible(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCGetControllerBoundsRect(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Rect bounds;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCGetControllerBoundsRect(_self->ob_itself,
+ &bounds);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ PyMac_BuildRect, &bounds);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCSetControllerBoundsRect(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Rect bounds;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &bounds))
+ return NULL;
+ _rv = MCSetControllerBoundsRect(_self->ob_itself,
+ &bounds);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCGetControllerBoundsRgn(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCGetControllerBoundsRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCGetWindowRgn(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ WindowPtr w;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &w))
+ return NULL;
+ _rv = MCGetWindowRgn(_self->ob_itself,
+ w);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCMovieChanged(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Movie m;
+ if (!PyArg_ParseTuple(_args, "O&",
+ MovieObj_Convert, &m))
+ return NULL;
+ _rv = MCMovieChanged(_self->ob_itself,
+ m);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCSetDuration(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "l",
+ &duration))
+ return NULL;
+ _rv = MCSetDuration(_self->ob_itself,
+ duration);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCGetCurrentTime(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue _rv;
+ TimeScale scale;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCGetCurrentTime(_self->ob_itself,
+ &scale);
+ _res = Py_BuildValue("ll",
+ _rv,
+ scale);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCNewAttachedController(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Movie theMovie;
+ WindowPtr w;
+ Point where;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ MovieObj_Convert, &theMovie,
+ WinObj_Convert, &w,
+ PyMac_GetPoint, &where))
+ return NULL;
+ _rv = MCNewAttachedController(_self->ob_itself,
+ theMovie,
+ w,
+ where);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCDraw(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ WindowPtr w;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &w))
+ return NULL;
+ _rv = MCDraw(_self->ob_itself,
+ w);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCActivate(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ WindowPtr w;
+ Boolean activate;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ WinObj_Convert, &w,
+ &activate))
+ return NULL;
+ _rv = MCActivate(_self->ob_itself,
+ w,
+ activate);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCIdle(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCIdle(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCKey(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ SInt8 key;
+ long modifiers;
+ if (!PyArg_ParseTuple(_args, "bl",
+ &key,
+ &modifiers))
+ return NULL;
+ _rv = MCKey(_self->ob_itself,
+ key,
+ modifiers);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCClick(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ WindowPtr w;
+ Point where;
+ long when;
+ long modifiers;
+ if (!PyArg_ParseTuple(_args, "O&O&ll",
+ WinObj_Convert, &w,
+ PyMac_GetPoint, &where,
+ &when,
+ &modifiers))
+ return NULL;
+ _rv = MCClick(_self->ob_itself,
+ w,
+ where,
+ when,
+ modifiers);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCEnableEditing(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Boolean enabled;
+ if (!PyArg_ParseTuple(_args, "b",
+ &enabled))
+ return NULL;
+ _rv = MCEnableEditing(_self->ob_itself,
+ enabled);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCIsEditingEnabled(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCIsEditingEnabled(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCCopy(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Movie _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCCopy(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCCut(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Movie _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCCut(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCPaste(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Movie srcMovie;
+ if (!PyArg_ParseTuple(_args, "O&",
+ MovieObj_Convert, &srcMovie))
+ return NULL;
+ _rv = MCPaste(_self->ob_itself,
+ srcMovie);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCClear(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCClear(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCUndo(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCUndo(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCPositionController(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Rect movieRect;
+ Rect controllerRect;
+ long someFlags;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ PyMac_GetRect, &movieRect,
+ PyMac_GetRect, &controllerRect,
+ &someFlags))
+ return NULL;
+ _rv = MCPositionController(_self->ob_itself,
+ &movieRect,
+ &controllerRect,
+ someFlags);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCGetControllerInfo(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ long someFlags;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCGetControllerInfo(_self->ob_itself,
+ &someFlags);
+ _res = Py_BuildValue("ll",
+ _rv,
+ someFlags);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCSetClip(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ RgnHandle theClip;
+ RgnHandle movieClip;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &theClip,
+ ResObj_Convert, &movieClip))
+ return NULL;
+ _rv = MCSetClip(_self->ob_itself,
+ theClip,
+ movieClip);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCGetClip(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ RgnHandle theClip;
+ RgnHandle movieClip;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MCGetClip(_self->ob_itself,
+ &theClip,
+ &movieClip);
+ _res = Py_BuildValue("lO&O&",
+ _rv,
+ ResObj_New, theClip,
+ ResObj_New, movieClip);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCDrawBadge(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ RgnHandle movieRgn;
+ RgnHandle badgeRgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &movieRgn))
+ return NULL;
+ _rv = MCDrawBadge(_self->ob_itself,
+ movieRgn,
+ &badgeRgn);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ ResObj_New, badgeRgn);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCSetUpEditMenu(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ long modifiers;
+ MenuHandle mh;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &modifiers,
+ MenuObj_Convert, &mh))
+ return NULL;
+ _rv = MCSetUpEditMenu(_self->ob_itself,
+ modifiers,
+ mh);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCGetMenuString(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ long modifiers;
+ short item;
+ Str255 aString;
+ if (!PyArg_ParseTuple(_args, "lhO&",
+ &modifiers,
+ &item,
+ PyMac_GetStr255, aString))
+ return NULL;
+ _rv = MCGetMenuString(_self->ob_itself,
+ modifiers,
+ item,
+ aString);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCPtInController(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Point thePt;
+ Boolean inController;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &thePt))
+ return NULL;
+ _rv = MCPtInController(_self->ob_itself,
+ thePt,
+ &inController);
+ _res = Py_BuildValue("lb",
+ _rv,
+ inController);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCInvalidate(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ WindowPtr w;
+ RgnHandle invalidRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ WinObj_Convert, &w,
+ ResObj_Convert, &invalidRgn))
+ return NULL;
+ _rv = MCInvalidate(_self->ob_itself,
+ w,
+ invalidRgn);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCAdjustCursor(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ WindowPtr w;
+ Point where;
+ long modifiers;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ WinObj_Convert, &w,
+ PyMac_GetPoint, &where,
+ &modifiers))
+ return NULL;
+ _rv = MCAdjustCursor(_self->ob_itself,
+ w,
+ where,
+ modifiers);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieCtlObj_MCGetInterfaceElement(MovieControllerObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MCInterfaceElement whichElement;
+ void * element;
+ if (!PyArg_ParseTuple(_args, "ls",
+ &whichElement,
+ &element))
+ return NULL;
+ _rv = MCGetInterfaceElement(_self->ob_itself,
+ whichElement,
+ element);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyMethodDef MovieCtlObj_methods[] = {
+ {"MCSetMovie", (PyCFunction)MovieCtlObj_MCSetMovie, 1,
+ "(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)"},
+ {"MCGetIndMovie", (PyCFunction)MovieCtlObj_MCGetIndMovie, 1,
+ "(short index) -> (Movie _rv)"},
+ {"MCRemoveAllMovies", (PyCFunction)MovieCtlObj_MCRemoveAllMovies, 1,
+ "() -> (ComponentResult _rv)"},
+ {"MCRemoveAMovie", (PyCFunction)MovieCtlObj_MCRemoveAMovie, 1,
+ "(Movie m) -> (ComponentResult _rv)"},
+ {"MCRemoveMovie", (PyCFunction)MovieCtlObj_MCRemoveMovie, 1,
+ "() -> (ComponentResult _rv)"},
+ {"MCIsPlayerEvent", (PyCFunction)MovieCtlObj_MCIsPlayerEvent, 1,
+ "(EventRecord e) -> (ComponentResult _rv)"},
+ {"MCDoAction", (PyCFunction)MovieCtlObj_MCDoAction, 1,
+ "(short action, void * params) -> (ComponentResult _rv)"},
+ {"MCSetControllerAttached", (PyCFunction)MovieCtlObj_MCSetControllerAttached, 1,
+ "(Boolean attach) -> (ComponentResult _rv)"},
+ {"MCIsControllerAttached", (PyCFunction)MovieCtlObj_MCIsControllerAttached, 1,
+ "() -> (ComponentResult _rv)"},
+ {"MCSetControllerPort", (PyCFunction)MovieCtlObj_MCSetControllerPort, 1,
+ "(CGrafPtr gp) -> (ComponentResult _rv)"},
+ {"MCGetControllerPort", (PyCFunction)MovieCtlObj_MCGetControllerPort, 1,
+ "() -> (CGrafPtr _rv)"},
+ {"MCSetVisible", (PyCFunction)MovieCtlObj_MCSetVisible, 1,
+ "(Boolean visible) -> (ComponentResult _rv)"},
+ {"MCGetVisible", (PyCFunction)MovieCtlObj_MCGetVisible, 1,
+ "() -> (ComponentResult _rv)"},
+ {"MCGetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRect, 1,
+ "() -> (ComponentResult _rv, Rect bounds)"},
+ {"MCSetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCSetControllerBoundsRect, 1,
+ "(Rect bounds) -> (ComponentResult _rv)"},
+ {"MCGetControllerBoundsRgn", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRgn, 1,
+ "() -> (RgnHandle _rv)"},
+ {"MCGetWindowRgn", (PyCFunction)MovieCtlObj_MCGetWindowRgn, 1,
+ "(WindowPtr w) -> (RgnHandle _rv)"},
+ {"MCMovieChanged", (PyCFunction)MovieCtlObj_MCMovieChanged, 1,
+ "(Movie m) -> (ComponentResult _rv)"},
+ {"MCSetDuration", (PyCFunction)MovieCtlObj_MCSetDuration, 1,
+ "(TimeValue duration) -> (ComponentResult _rv)"},
+ {"MCGetCurrentTime", (PyCFunction)MovieCtlObj_MCGetCurrentTime, 1,
+ "() -> (TimeValue _rv, TimeScale scale)"},
+ {"MCNewAttachedController", (PyCFunction)MovieCtlObj_MCNewAttachedController, 1,
+ "(Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)"},
+ {"MCDraw", (PyCFunction)MovieCtlObj_MCDraw, 1,
+ "(WindowPtr w) -> (ComponentResult _rv)"},
+ {"MCActivate", (PyCFunction)MovieCtlObj_MCActivate, 1,
+ "(WindowPtr w, Boolean activate) -> (ComponentResult _rv)"},
+ {"MCIdle", (PyCFunction)MovieCtlObj_MCIdle, 1,
+ "() -> (ComponentResult _rv)"},
+ {"MCKey", (PyCFunction)MovieCtlObj_MCKey, 1,
+ "(SInt8 key, long modifiers) -> (ComponentResult _rv)"},
+ {"MCClick", (PyCFunction)MovieCtlObj_MCClick, 1,
+ "(WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)"},
+ {"MCEnableEditing", (PyCFunction)MovieCtlObj_MCEnableEditing, 1,
+ "(Boolean enabled) -> (ComponentResult _rv)"},
+ {"MCIsEditingEnabled", (PyCFunction)MovieCtlObj_MCIsEditingEnabled, 1,
+ "() -> (long _rv)"},
+ {"MCCopy", (PyCFunction)MovieCtlObj_MCCopy, 1,
+ "() -> (Movie _rv)"},
+ {"MCCut", (PyCFunction)MovieCtlObj_MCCut, 1,
+ "() -> (Movie _rv)"},
+ {"MCPaste", (PyCFunction)MovieCtlObj_MCPaste, 1,
+ "(Movie srcMovie) -> (ComponentResult _rv)"},
+ {"MCClear", (PyCFunction)MovieCtlObj_MCClear, 1,
+ "() -> (ComponentResult _rv)"},
+ {"MCUndo", (PyCFunction)MovieCtlObj_MCUndo, 1,
+ "() -> (ComponentResult _rv)"},
+ {"MCPositionController", (PyCFunction)MovieCtlObj_MCPositionController, 1,
+ "(Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)"},
+ {"MCGetControllerInfo", (PyCFunction)MovieCtlObj_MCGetControllerInfo, 1,
+ "() -> (ComponentResult _rv, long someFlags)"},
+ {"MCSetClip", (PyCFunction)MovieCtlObj_MCSetClip, 1,
+ "(RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)"},
+ {"MCGetClip", (PyCFunction)MovieCtlObj_MCGetClip, 1,
+ "() -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)"},
+ {"MCDrawBadge", (PyCFunction)MovieCtlObj_MCDrawBadge, 1,
+ "(RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)"},
+ {"MCSetUpEditMenu", (PyCFunction)MovieCtlObj_MCSetUpEditMenu, 1,
+ "(long modifiers, MenuHandle mh) -> (ComponentResult _rv)"},
+ {"MCGetMenuString", (PyCFunction)MovieCtlObj_MCGetMenuString, 1,
+ "(long modifiers, short item, Str255 aString) -> (ComponentResult _rv)"},
+ {"MCPtInController", (PyCFunction)MovieCtlObj_MCPtInController, 1,
+ "(Point thePt) -> (ComponentResult _rv, Boolean inController)"},
+ {"MCInvalidate", (PyCFunction)MovieCtlObj_MCInvalidate, 1,
+ "(WindowPtr w, RgnHandle invalidRgn) -> (ComponentResult _rv)"},
+ {"MCAdjustCursor", (PyCFunction)MovieCtlObj_MCAdjustCursor, 1,
+ "(WindowPtr w, Point where, long modifiers) -> (ComponentResult _rv)"},
+ {"MCGetInterfaceElement", (PyCFunction)MovieCtlObj_MCGetInterfaceElement, 1,
+ "(MCInterfaceElement whichElement, void * element) -> (ComponentResult _rv)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain MovieCtlObj_chain = { MovieCtlObj_methods, NULL };
+
+static PyObject *MovieCtlObj_getattr(MovieControllerObject *self, char *name)
+{
+ return Py_FindMethodInChain(&MovieCtlObj_chain, (PyObject *)self, name);
+}
+
+#define MovieCtlObj_setattr NULL
+
+#define MovieCtlObj_compare NULL
+
+#define MovieCtlObj_repr NULL
+
+#define MovieCtlObj_hash NULL
+
+PyTypeObject MovieController_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "MovieController", /*tp_name*/
+ sizeof(MovieControllerObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) MovieCtlObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) MovieCtlObj_getattr, /*tp_getattr*/
+ (setattrfunc) MovieCtlObj_setattr, /*tp_setattr*/
+ (cmpfunc) MovieCtlObj_compare, /*tp_compare*/
+ (reprfunc) MovieCtlObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) MovieCtlObj_hash, /*tp_hash*/
+};
+
+/* ---------------- End object type MovieController ----------------- */
+
+
+/* ---------------------- Object type TimeBase ---------------------- */
+
+PyTypeObject TimeBase_Type;
+
+#define TimeBaseObj_Check(x) ((x)->ob_type == &TimeBase_Type)
+
+typedef struct TimeBaseObject {
+ PyObject_HEAD
+ TimeBase ob_itself;
+} TimeBaseObject;
+
+PyObject *TimeBaseObj_New(TimeBase itself)
+{
+ TimeBaseObject *it;
+ if (itself == NULL) {
+ PyErr_SetString(Qt_Error,"Cannot create null TimeBase");
+ return NULL;
+ }
+ it = PyObject_NEW(TimeBaseObject, &TimeBase_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+TimeBaseObj_Convert(PyObject *v, TimeBase *p_itself)
+{
+ if (!TimeBaseObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "TimeBase required");
+ return 0;
+ }
+ *p_itself = ((TimeBaseObject *)v)->ob_itself;
+ return 1;
+}
+
+static void TimeBaseObj_dealloc(TimeBaseObject *self)
+{
+ /* Cleanup of self->ob_itself goes here */
+ PyMem_DEL(self);
+}
+
+static PyObject *TimeBaseObj_DisposeTimeBase(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DisposeTimeBase(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TimeBaseObj_GetTimeBaseTime(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue _rv;
+ TimeScale s;
+ TimeRecord tr;
+ if (!PyArg_ParseTuple(_args, "l",
+ &s))
+ return NULL;
+ _rv = GetTimeBaseTime(_self->ob_itself,
+ s,
+ &tr);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ QtTimeRecord_New, &tr);
+ return _res;
+}
+
+static PyObject *TimeBaseObj_SetTimeBaseTime(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeRecord tr;
+ if (!PyArg_ParseTuple(_args, "O&",
+ QtTimeRecord_Convert, &tr))
+ return NULL;
+ SetTimeBaseTime(_self->ob_itself,
+ &tr);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TimeBaseObj_SetTimeBaseValue(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue t;
+ TimeScale s;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &t,
+ &s))
+ return NULL;
+ SetTimeBaseValue(_self->ob_itself,
+ t,
+ s);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TimeBaseObj_GetTimeBaseRate(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Fixed _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTimeBaseRate(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildFixed, _rv);
+ return _res;
+}
+
+static PyObject *TimeBaseObj_SetTimeBaseRate(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Fixed r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFixed, &r))
+ return NULL;
+ SetTimeBaseRate(_self->ob_itself,
+ r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TimeBaseObj_GetTimeBaseStartTime(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue _rv;
+ TimeScale s;
+ TimeRecord tr;
+ if (!PyArg_ParseTuple(_args, "l",
+ &s))
+ return NULL;
+ _rv = GetTimeBaseStartTime(_self->ob_itself,
+ s,
+ &tr);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ QtTimeRecord_New, &tr);
+ return _res;
+}
+
+static PyObject *TimeBaseObj_SetTimeBaseStartTime(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeRecord tr;
+ if (!PyArg_ParseTuple(_args, "O&",
+ QtTimeRecord_Convert, &tr))
+ return NULL;
+ SetTimeBaseStartTime(_self->ob_itself,
+ &tr);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TimeBaseObj_GetTimeBaseStopTime(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue _rv;
+ TimeScale s;
+ TimeRecord tr;
+ if (!PyArg_ParseTuple(_args, "l",
+ &s))
+ return NULL;
+ _rv = GetTimeBaseStopTime(_self->ob_itself,
+ s,
+ &tr);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ QtTimeRecord_New, &tr);
+ return _res;
+}
+
+static PyObject *TimeBaseObj_SetTimeBaseStopTime(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeRecord tr;
+ if (!PyArg_ParseTuple(_args, "O&",
+ QtTimeRecord_Convert, &tr))
+ return NULL;
+ SetTimeBaseStopTime(_self->ob_itself,
+ &tr);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TimeBaseObj_GetTimeBaseFlags(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTimeBaseFlags(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TimeBaseObj_SetTimeBaseFlags(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long timeBaseFlags;
+ if (!PyArg_ParseTuple(_args, "l",
+ &timeBaseFlags))
+ return NULL;
+ SetTimeBaseFlags(_self->ob_itself,
+ timeBaseFlags);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TimeBaseObj_SetTimeBaseMasterTimeBase(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeBase master;
+ TimeRecord slaveZero;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ TimeBaseObj_Convert, &master,
+ QtTimeRecord_Convert, &slaveZero))
+ return NULL;
+ SetTimeBaseMasterTimeBase(_self->ob_itself,
+ master,
+ &slaveZero);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TimeBaseObj_GetTimeBaseMasterTimeBase(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeBase _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTimeBaseMasterTimeBase(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ TimeBaseObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TimeBaseObj_SetTimeBaseMasterClock(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Component clockMeister;
+ TimeRecord slaveZero;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ CmpObj_Convert, &clockMeister,
+ QtTimeRecord_Convert, &slaveZero))
+ return NULL;
+ SetTimeBaseMasterClock(_self->ob_itself,
+ clockMeister,
+ &slaveZero);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TimeBaseObj_GetTimeBaseMasterClock(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentInstance _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTimeBaseMasterClock(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CmpInstObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TimeBaseObj_GetTimeBaseStatus(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ TimeRecord unpinnedTime;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTimeBaseStatus(_self->ob_itself,
+ &unpinnedTime);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ QtTimeRecord_New, &unpinnedTime);
+ return _res;
+}
+
+static PyObject *TimeBaseObj_SetTimeBaseZero(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeRecord zero;
+ if (!PyArg_ParseTuple(_args, "O&",
+ QtTimeRecord_Convert, &zero))
+ return NULL;
+ SetTimeBaseZero(_self->ob_itself,
+ &zero);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TimeBaseObj_GetTimeBaseEffectiveRate(TimeBaseObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Fixed _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTimeBaseEffectiveRate(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildFixed, _rv);
+ return _res;
+}
+
+static PyMethodDef TimeBaseObj_methods[] = {
+ {"DisposeTimeBase", (PyCFunction)TimeBaseObj_DisposeTimeBase, 1,
+ "() -> None"},
+ {"GetTimeBaseTime", (PyCFunction)TimeBaseObj_GetTimeBaseTime, 1,
+ "(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"},
+ {"SetTimeBaseTime", (PyCFunction)TimeBaseObj_SetTimeBaseTime, 1,
+ "(TimeRecord tr) -> None"},
+ {"SetTimeBaseValue", (PyCFunction)TimeBaseObj_SetTimeBaseValue, 1,
+ "(TimeValue t, TimeScale s) -> None"},
+ {"GetTimeBaseRate", (PyCFunction)TimeBaseObj_GetTimeBaseRate, 1,
+ "() -> (Fixed _rv)"},
+ {"SetTimeBaseRate", (PyCFunction)TimeBaseObj_SetTimeBaseRate, 1,
+ "(Fixed r) -> None"},
+ {"GetTimeBaseStartTime", (PyCFunction)TimeBaseObj_GetTimeBaseStartTime, 1,
+ "(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"},
+ {"SetTimeBaseStartTime", (PyCFunction)TimeBaseObj_SetTimeBaseStartTime, 1,
+ "(TimeRecord tr) -> None"},
+ {"GetTimeBaseStopTime", (PyCFunction)TimeBaseObj_GetTimeBaseStopTime, 1,
+ "(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"},
+ {"SetTimeBaseStopTime", (PyCFunction)TimeBaseObj_SetTimeBaseStopTime, 1,
+ "(TimeRecord tr) -> None"},
+ {"GetTimeBaseFlags", (PyCFunction)TimeBaseObj_GetTimeBaseFlags, 1,
+ "() -> (long _rv)"},
+ {"SetTimeBaseFlags", (PyCFunction)TimeBaseObj_SetTimeBaseFlags, 1,
+ "(long timeBaseFlags) -> None"},
+ {"SetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_SetTimeBaseMasterTimeBase, 1,
+ "(TimeBase master, TimeRecord slaveZero) -> None"},
+ {"GetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_GetTimeBaseMasterTimeBase, 1,
+ "() -> (TimeBase _rv)"},
+ {"SetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_SetTimeBaseMasterClock, 1,
+ "(Component clockMeister, TimeRecord slaveZero) -> None"},
+ {"GetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_GetTimeBaseMasterClock, 1,
+ "() -> (ComponentInstance _rv)"},
+ {"GetTimeBaseStatus", (PyCFunction)TimeBaseObj_GetTimeBaseStatus, 1,
+ "() -> (long _rv, TimeRecord unpinnedTime)"},
+ {"SetTimeBaseZero", (PyCFunction)TimeBaseObj_SetTimeBaseZero, 1,
+ "(TimeRecord zero) -> None"},
+ {"GetTimeBaseEffectiveRate", (PyCFunction)TimeBaseObj_GetTimeBaseEffectiveRate, 1,
+ "() -> (Fixed _rv)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain TimeBaseObj_chain = { TimeBaseObj_methods, NULL };
+
+static PyObject *TimeBaseObj_getattr(TimeBaseObject *self, char *name)
+{
+ return Py_FindMethodInChain(&TimeBaseObj_chain, (PyObject *)self, name);
+}
+
+#define TimeBaseObj_setattr NULL
+
+#define TimeBaseObj_compare NULL
+
+#define TimeBaseObj_repr NULL
+
+#define TimeBaseObj_hash NULL
+
+PyTypeObject TimeBase_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "TimeBase", /*tp_name*/
+ sizeof(TimeBaseObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) TimeBaseObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) TimeBaseObj_getattr, /*tp_getattr*/
+ (setattrfunc) TimeBaseObj_setattr, /*tp_setattr*/
+ (cmpfunc) TimeBaseObj_compare, /*tp_compare*/
+ (reprfunc) TimeBaseObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) TimeBaseObj_hash, /*tp_hash*/
+};
+
+/* -------------------- End object type TimeBase -------------------- */
+
+
+/* ---------------------- Object type UserData ---------------------- */
+
+PyTypeObject UserData_Type;
+
+#define UserDataObj_Check(x) ((x)->ob_type == &UserData_Type)
+
+typedef struct UserDataObject {
+ PyObject_HEAD
+ UserData ob_itself;
+} UserDataObject;
+
+PyObject *UserDataObj_New(UserData itself)
+{
+ UserDataObject *it;
+ if (itself == NULL) {
+ PyErr_SetString(Qt_Error,"Cannot create null UserData");
+ return NULL;
+ }
+ it = PyObject_NEW(UserDataObject, &UserData_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+UserDataObj_Convert(PyObject *v, UserData *p_itself)
+{
+ if (!UserDataObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "UserData required");
+ return 0;
+ }
+ *p_itself = ((UserDataObject *)v)->ob_itself;
+ return 1;
+}
+
+static void UserDataObj_dealloc(UserDataObject *self)
+{
+ DisposeUserData(self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *UserDataObj_GetUserData(UserDataObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle data;
+ OSType udType;
+ long index;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ ResObj_Convert, &data,
+ PyMac_GetOSType, &udType,
+ &index))
+ return NULL;
+ _err = GetUserData(_self->ob_itself,
+ data,
+ udType,
+ index);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *UserDataObj_AddUserData(UserDataObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle data;
+ OSType udType;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &data,
+ PyMac_GetOSType, &udType))
+ return NULL;
+ _err = AddUserData(_self->ob_itself,
+ data,
+ udType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *UserDataObj_RemoveUserData(UserDataObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType udType;
+ long index;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetOSType, &udType,
+ &index))
+ return NULL;
+ _err = RemoveUserData(_self->ob_itself,
+ udType,
+ index);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *UserDataObj_CountUserDataType(UserDataObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ OSType udType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &udType))
+ return NULL;
+ _rv = CountUserDataType(_self->ob_itself,
+ udType);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *UserDataObj_GetNextUserDataType(UserDataObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ OSType udType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &udType))
+ return NULL;
+ _rv = GetNextUserDataType(_self->ob_itself,
+ udType);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *UserDataObj_AddUserDataText(UserDataObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle data;
+ OSType udType;
+ long index;
+ short itlRegionTag;
+ if (!PyArg_ParseTuple(_args, "O&O&lh",
+ ResObj_Convert, &data,
+ PyMac_GetOSType, &udType,
+ &index,
+ &itlRegionTag))
+ return NULL;
+ _err = AddUserDataText(_self->ob_itself,
+ data,
+ udType,
+ index,
+ itlRegionTag);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *UserDataObj_GetUserDataText(UserDataObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle data;
+ OSType udType;
+ long index;
+ short itlRegionTag;
+ if (!PyArg_ParseTuple(_args, "O&O&lh",
+ ResObj_Convert, &data,
+ PyMac_GetOSType, &udType,
+ &index,
+ &itlRegionTag))
+ return NULL;
+ _err = GetUserDataText(_self->ob_itself,
+ data,
+ udType,
+ index,
+ itlRegionTag);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *UserDataObj_RemoveUserDataText(UserDataObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType udType;
+ long index;
+ short itlRegionTag;
+ if (!PyArg_ParseTuple(_args, "O&lh",
+ PyMac_GetOSType, &udType,
+ &index,
+ &itlRegionTag))
+ return NULL;
+ _err = RemoveUserDataText(_self->ob_itself,
+ udType,
+ index,
+ itlRegionTag);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *UserDataObj_PutUserDataIntoHandle(UserDataObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle h;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &h))
+ return NULL;
+ _err = PutUserDataIntoHandle(_self->ob_itself,
+ h);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef UserDataObj_methods[] = {
+ {"GetUserData", (PyCFunction)UserDataObj_GetUserData, 1,
+ "(Handle data, OSType udType, long index) -> None"},
+ {"AddUserData", (PyCFunction)UserDataObj_AddUserData, 1,
+ "(Handle data, OSType udType) -> None"},
+ {"RemoveUserData", (PyCFunction)UserDataObj_RemoveUserData, 1,
+ "(OSType udType, long index) -> None"},
+ {"CountUserDataType", (PyCFunction)UserDataObj_CountUserDataType, 1,
+ "(OSType udType) -> (short _rv)"},
+ {"GetNextUserDataType", (PyCFunction)UserDataObj_GetNextUserDataType, 1,
+ "(OSType udType) -> (long _rv)"},
+ {"AddUserDataText", (PyCFunction)UserDataObj_AddUserDataText, 1,
+ "(Handle data, OSType udType, long index, short itlRegionTag) -> None"},
+ {"GetUserDataText", (PyCFunction)UserDataObj_GetUserDataText, 1,
+ "(Handle data, OSType udType, long index, short itlRegionTag) -> None"},
+ {"RemoveUserDataText", (PyCFunction)UserDataObj_RemoveUserDataText, 1,
+ "(OSType udType, long index, short itlRegionTag) -> None"},
+ {"PutUserDataIntoHandle", (PyCFunction)UserDataObj_PutUserDataIntoHandle, 1,
+ "(Handle h) -> None"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain UserDataObj_chain = { UserDataObj_methods, NULL };
+
+static PyObject *UserDataObj_getattr(UserDataObject *self, char *name)
+{
+ return Py_FindMethodInChain(&UserDataObj_chain, (PyObject *)self, name);
+}
+
+#define UserDataObj_setattr NULL
+
+#define UserDataObj_compare NULL
+
+#define UserDataObj_repr NULL
+
+#define UserDataObj_hash NULL
+
+PyTypeObject UserData_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "UserData", /*tp_name*/
+ sizeof(UserDataObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) UserDataObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) UserDataObj_getattr, /*tp_getattr*/
+ (setattrfunc) UserDataObj_setattr, /*tp_setattr*/
+ (cmpfunc) UserDataObj_compare, /*tp_compare*/
+ (reprfunc) UserDataObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) UserDataObj_hash, /*tp_hash*/
+};
+
+/* -------------------- End object type UserData -------------------- */
+
+
+/* ----------------------- Object type Media ------------------------ */
+
+PyTypeObject Media_Type;
+
+#define MediaObj_Check(x) ((x)->ob_type == &Media_Type)
+
+typedef struct MediaObject {
+ PyObject_HEAD
+ Media ob_itself;
+} MediaObject;
+
+PyObject *MediaObj_New(Media itself)
+{
+ MediaObject *it;
+ if (itself == NULL) {
+ PyErr_SetString(Qt_Error,"Cannot create null Media");
+ return NULL;
+ }
+ it = PyObject_NEW(MediaObject, &Media_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+MediaObj_Convert(PyObject *v, Media *p_itself)
+{
+ if (!MediaObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "Media required");
+ return 0;
+ }
+ *p_itself = ((MediaObject *)v)->ob_itself;
+ return 1;
+}
+
+static void MediaObj_dealloc(MediaObject *self)
+{
+ DisposeTrackMedia(self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *MediaObj_LoadMediaIntoRam(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue time;
+ TimeValue duration;
+ long flags;
+ if (!PyArg_ParseTuple(_args, "lll",
+ &time,
+ &duration,
+ &flags))
+ return NULL;
+ _err = LoadMediaIntoRam(_self->ob_itself,
+ time,
+ duration,
+ flags);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaTrack(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Track _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMediaTrack(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ TrackObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaCreationTime(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ unsigned long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMediaCreationTime(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaModificationTime(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ unsigned long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMediaModificationTime(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaTimeScale(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeScale _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMediaTimeScale(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MediaObj_SetMediaTimeScale(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeScale timeScale;
+ if (!PyArg_ParseTuple(_args, "l",
+ &timeScale))
+ return NULL;
+ SetMediaTimeScale(_self->ob_itself,
+ timeScale);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaDuration(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMediaDuration(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaLanguage(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMediaLanguage(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *MediaObj_SetMediaLanguage(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short language;
+ if (!PyArg_ParseTuple(_args, "h",
+ &language))
+ return NULL;
+ SetMediaLanguage(_self->ob_itself,
+ language);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaQuality(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMediaQuality(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *MediaObj_SetMediaQuality(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short quality;
+ if (!PyArg_ParseTuple(_args, "h",
+ &quality))
+ return NULL;
+ SetMediaQuality(_self->ob_itself,
+ quality);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaHandlerDescription(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSType mediaType;
+ Str255 creatorName;
+ OSType creatorManufacturer;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, creatorName))
+ return NULL;
+ GetMediaHandlerDescription(_self->ob_itself,
+ &mediaType,
+ creatorName,
+ &creatorManufacturer);
+ _res = Py_BuildValue("O&O&",
+ PyMac_BuildOSType, mediaType,
+ PyMac_BuildOSType, creatorManufacturer);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaUserData(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UserData _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMediaUserData(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ UserDataObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaHandler(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MediaHandler _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMediaHandler(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CmpInstObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MediaObj_SetMediaHandler(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ MediaHandlerComponent mH;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpObj_Convert, &mH))
+ return NULL;
+ _err = SetMediaHandler(_self->ob_itself,
+ mH);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_BeginMediaEdits(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = BeginMediaEdits(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_EndMediaEdits(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = EndMediaEdits(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_SetMediaDefaultDataRefIndex(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short index;
+ if (!PyArg_ParseTuple(_args, "h",
+ &index))
+ return NULL;
+ _err = SetMediaDefaultDataRefIndex(_self->ob_itself,
+ index);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaDataHandlerDescription(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short index;
+ OSType dhType;
+ Str255 creatorName;
+ OSType creatorManufacturer;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &index,
+ PyMac_GetStr255, creatorName))
+ return NULL;
+ GetMediaDataHandlerDescription(_self->ob_itself,
+ index,
+ &dhType,
+ creatorName,
+ &creatorManufacturer);
+ _res = Py_BuildValue("O&O&",
+ PyMac_BuildOSType, dhType,
+ PyMac_BuildOSType, creatorManufacturer);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaDataHandler(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ DataHandler _rv;
+ short index;
+ if (!PyArg_ParseTuple(_args, "h",
+ &index))
+ return NULL;
+ _rv = GetMediaDataHandler(_self->ob_itself,
+ index);
+ _res = Py_BuildValue("O&",
+ CmpInstObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MediaObj_SetMediaDataHandler(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short index;
+ DataHandlerComponent dataHandler;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &index,
+ CmpObj_Convert, &dataHandler))
+ return NULL;
+ _err = SetMediaDataHandler(_self->ob_itself,
+ index,
+ dataHandler);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaSampleDescriptionCount(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMediaSampleDescriptionCount(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaSampleDescription(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long index;
+ SampleDescriptionHandle descH;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &index,
+ ResObj_Convert, &descH))
+ return NULL;
+ GetMediaSampleDescription(_self->ob_itself,
+ index,
+ descH);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_SetMediaSampleDescription(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long index;
+ SampleDescriptionHandle descH;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &index,
+ ResObj_Convert, &descH))
+ return NULL;
+ _err = SetMediaSampleDescription(_self->ob_itself,
+ index,
+ descH);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaSampleCount(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMediaSampleCount(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaSyncSampleCount(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMediaSyncSampleCount(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MediaObj_SampleNumToMediaTime(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long logicalSampleNum;
+ TimeValue sampleTime;
+ TimeValue sampleDuration;
+ if (!PyArg_ParseTuple(_args, "l",
+ &logicalSampleNum))
+ return NULL;
+ SampleNumToMediaTime(_self->ob_itself,
+ logicalSampleNum,
+ &sampleTime,
+ &sampleDuration);
+ _res = Py_BuildValue("ll",
+ sampleTime,
+ sampleDuration);
+ return _res;
+}
+
+static PyObject *MediaObj_MediaTimeToSampleNum(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue time;
+ long sampleNum;
+ TimeValue sampleTime;
+ TimeValue sampleDuration;
+ if (!PyArg_ParseTuple(_args, "l",
+ &time))
+ return NULL;
+ MediaTimeToSampleNum(_self->ob_itself,
+ time,
+ &sampleNum,
+ &sampleTime,
+ &sampleDuration);
+ _res = Py_BuildValue("lll",
+ sampleNum,
+ sampleTime,
+ sampleDuration);
+ return _res;
+}
+
+static PyObject *MediaObj_AddMediaSample(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataIn;
+ long inOffset;
+ unsigned long size;
+ TimeValue durationPerSample;
+ SampleDescriptionHandle sampleDescriptionH;
+ long numberOfSamples;
+ short sampleFlags;
+ TimeValue sampleTime;
+ if (!PyArg_ParseTuple(_args, "O&lllO&lh",
+ ResObj_Convert, &dataIn,
+ &inOffset,
+ &size,
+ &durationPerSample,
+ ResObj_Convert, &sampleDescriptionH,
+ &numberOfSamples,
+ &sampleFlags))
+ return NULL;
+ _err = AddMediaSample(_self->ob_itself,
+ dataIn,
+ inOffset,
+ size,
+ durationPerSample,
+ sampleDescriptionH,
+ numberOfSamples,
+ sampleFlags,
+ &sampleTime);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ sampleTime);
+ return _res;
+}
+
+static PyObject *MediaObj_AddMediaSampleReference(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long dataOffset;
+ unsigned long size;
+ TimeValue durationPerSample;
+ SampleDescriptionHandle sampleDescriptionH;
+ long numberOfSamples;
+ short sampleFlags;
+ TimeValue sampleTime;
+ if (!PyArg_ParseTuple(_args, "lllO&lh",
+ &dataOffset,
+ &size,
+ &durationPerSample,
+ ResObj_Convert, &sampleDescriptionH,
+ &numberOfSamples,
+ &sampleFlags))
+ return NULL;
+ _err = AddMediaSampleReference(_self->ob_itself,
+ dataOffset,
+ size,
+ durationPerSample,
+ sampleDescriptionH,
+ numberOfSamples,
+ sampleFlags,
+ &sampleTime);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ sampleTime);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaSample(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataOut;
+ long maxSizeToGrow;
+ long size;
+ TimeValue time;
+ TimeValue sampleTime;
+ TimeValue durationPerSample;
+ SampleDescriptionHandle sampleDescriptionH;
+ long sampleDescriptionIndex;
+ long maxNumberOfSamples;
+ long numberOfSamples;
+ short sampleFlags;
+ if (!PyArg_ParseTuple(_args, "O&llO&l",
+ ResObj_Convert, &dataOut,
+ &maxSizeToGrow,
+ &time,
+ ResObj_Convert, &sampleDescriptionH,
+ &maxNumberOfSamples))
+ return NULL;
+ _err = GetMediaSample(_self->ob_itself,
+ dataOut,
+ maxSizeToGrow,
+ &size,
+ time,
+ &sampleTime,
+ &durationPerSample,
+ sampleDescriptionH,
+ &sampleDescriptionIndex,
+ maxNumberOfSamples,
+ &numberOfSamples,
+ &sampleFlags);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("lllllh",
+ size,
+ sampleTime,
+ durationPerSample,
+ sampleDescriptionIndex,
+ numberOfSamples,
+ sampleFlags);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaSampleReference(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long dataOffset;
+ long size;
+ TimeValue time;
+ TimeValue sampleTime;
+ TimeValue durationPerSample;
+ SampleDescriptionHandle sampleDescriptionH;
+ long sampleDescriptionIndex;
+ long maxNumberOfSamples;
+ long numberOfSamples;
+ short sampleFlags;
+ if (!PyArg_ParseTuple(_args, "lO&l",
+ &time,
+ ResObj_Convert, &sampleDescriptionH,
+ &maxNumberOfSamples))
+ return NULL;
+ _err = GetMediaSampleReference(_self->ob_itself,
+ &dataOffset,
+ &size,
+ time,
+ &sampleTime,
+ &durationPerSample,
+ sampleDescriptionH,
+ &sampleDescriptionIndex,
+ maxNumberOfSamples,
+ &numberOfSamples,
+ &sampleFlags);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("llllllh",
+ dataOffset,
+ size,
+ sampleTime,
+ durationPerSample,
+ sampleDescriptionIndex,
+ numberOfSamples,
+ sampleFlags);
+ return _res;
+}
+
+static PyObject *MediaObj_SetMediaPreferredChunkSize(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long maxChunkSize;
+ if (!PyArg_ParseTuple(_args, "l",
+ &maxChunkSize))
+ return NULL;
+ _err = SetMediaPreferredChunkSize(_self->ob_itself,
+ maxChunkSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaPreferredChunkSize(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long maxChunkSize;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetMediaPreferredChunkSize(_self->ob_itself,
+ &maxChunkSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ maxChunkSize);
+ return _res;
+}
+
+static PyObject *MediaObj_SetMediaShadowSync(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long frameDiffSampleNum;
+ long syncSampleNum;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &frameDiffSampleNum,
+ &syncSampleNum))
+ return NULL;
+ _err = SetMediaShadowSync(_self->ob_itself,
+ frameDiffSampleNum,
+ syncSampleNum);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaShadowSync(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long frameDiffSampleNum;
+ long syncSampleNum;
+ if (!PyArg_ParseTuple(_args, "l",
+ &frameDiffSampleNum))
+ return NULL;
+ _err = GetMediaShadowSync(_self->ob_itself,
+ frameDiffSampleNum,
+ &syncSampleNum);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ syncSampleNum);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaDataSize(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ TimeValue startTime;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
+ return NULL;
+ _rv = GetMediaDataSize(_self->ob_itself,
+ startTime,
+ duration);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaDataSize64(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue startTime;
+ TimeValue duration;
+ wide dataSize;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
+ return NULL;
+ _err = GetMediaDataSize64(_self->ob_itself,
+ startTime,
+ duration,
+ &dataSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_Buildwide, dataSize);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaNextInterestingTime(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short interestingTimeFlags;
+ TimeValue time;
+ Fixed rate;
+ TimeValue interestingTime;
+ TimeValue interestingDuration;
+ if (!PyArg_ParseTuple(_args, "hlO&",
+ &interestingTimeFlags,
+ &time,
+ PyMac_GetFixed, &rate))
+ return NULL;
+ GetMediaNextInterestingTime(_self->ob_itself,
+ interestingTimeFlags,
+ time,
+ rate,
+ &interestingTime,
+ &interestingDuration);
+ _res = Py_BuildValue("ll",
+ interestingTime,
+ interestingDuration);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaDataRef(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short index;
+ Handle dataRef;
+ OSType dataRefType;
+ long dataRefAttributes;
+ if (!PyArg_ParseTuple(_args, "h",
+ &index))
+ return NULL;
+ _err = GetMediaDataRef(_self->ob_itself,
+ index,
+ &dataRef,
+ &dataRefType,
+ &dataRefAttributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&l",
+ ResObj_New, dataRef,
+ PyMac_BuildOSType, dataRefType,
+ dataRefAttributes);
+ return _res;
+}
+
+static PyObject *MediaObj_SetMediaDataRef(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short index;
+ Handle dataRef;
+ OSType dataRefType;
+ if (!PyArg_ParseTuple(_args, "hO&O&",
+ &index,
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
+ return NULL;
+ _err = SetMediaDataRef(_self->ob_itself,
+ index,
+ dataRef,
+ dataRefType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_SetMediaDataRefAttributes(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short index;
+ long dataRefAttributes;
+ if (!PyArg_ParseTuple(_args, "hl",
+ &index,
+ &dataRefAttributes))
+ return NULL;
+ _err = SetMediaDataRefAttributes(_self->ob_itself,
+ index,
+ dataRefAttributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_AddMediaDataRef(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short index;
+ Handle dataRef;
+ OSType dataRefType;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
+ return NULL;
+ _err = AddMediaDataRef(_self->ob_itself,
+ &index,
+ dataRef,
+ dataRefType);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ index);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaDataRefCount(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short count;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetMediaDataRefCount(_self->ob_itself,
+ &count);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ count);
+ return _res;
+}
+
+static PyObject *MediaObj_SetMediaPlayHints(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long flags;
+ long flagsMask;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &flags,
+ &flagsMask))
+ return NULL;
+ SetMediaPlayHints(_self->ob_itself,
+ flags,
+ flagsMask);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaPlayHints(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long flags;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetMediaPlayHints(_self->ob_itself,
+ &flags);
+ _res = Py_BuildValue("l",
+ flags);
+ return _res;
+}
+
+static PyObject *MediaObj_GetMediaNextInterestingTimeOnly(MediaObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short interestingTimeFlags;
+ TimeValue time;
+ Fixed rate;
+ TimeValue interestingTime;
+ if (!PyArg_ParseTuple(_args, "hlO&",
+ &interestingTimeFlags,
+ &time,
+ PyMac_GetFixed, &rate))
+ return NULL;
+ GetMediaNextInterestingTimeOnly(_self->ob_itself,
+ interestingTimeFlags,
+ time,
+ rate,
+ &interestingTime);
+ _res = Py_BuildValue("l",
+ interestingTime);
+ return _res;
+}
+
+static PyMethodDef MediaObj_methods[] = {
+ {"LoadMediaIntoRam", (PyCFunction)MediaObj_LoadMediaIntoRam, 1,
+ "(TimeValue time, TimeValue duration, long flags) -> None"},
+ {"GetMediaTrack", (PyCFunction)MediaObj_GetMediaTrack, 1,
+ "() -> (Track _rv)"},
+ {"GetMediaCreationTime", (PyCFunction)MediaObj_GetMediaCreationTime, 1,
+ "() -> (unsigned long _rv)"},
+ {"GetMediaModificationTime", (PyCFunction)MediaObj_GetMediaModificationTime, 1,
+ "() -> (unsigned long _rv)"},
+ {"GetMediaTimeScale", (PyCFunction)MediaObj_GetMediaTimeScale, 1,
+ "() -> (TimeScale _rv)"},
+ {"SetMediaTimeScale", (PyCFunction)MediaObj_SetMediaTimeScale, 1,
+ "(TimeScale timeScale) -> None"},
+ {"GetMediaDuration", (PyCFunction)MediaObj_GetMediaDuration, 1,
+ "() -> (TimeValue _rv)"},
+ {"GetMediaLanguage", (PyCFunction)MediaObj_GetMediaLanguage, 1,
+ "() -> (short _rv)"},
+ {"SetMediaLanguage", (PyCFunction)MediaObj_SetMediaLanguage, 1,
+ "(short language) -> None"},
+ {"GetMediaQuality", (PyCFunction)MediaObj_GetMediaQuality, 1,
+ "() -> (short _rv)"},
+ {"SetMediaQuality", (PyCFunction)MediaObj_SetMediaQuality, 1,
+ "(short quality) -> None"},
+ {"GetMediaHandlerDescription", (PyCFunction)MediaObj_GetMediaHandlerDescription, 1,
+ "(Str255 creatorName) -> (OSType mediaType, OSType creatorManufacturer)"},
+ {"GetMediaUserData", (PyCFunction)MediaObj_GetMediaUserData, 1,
+ "() -> (UserData _rv)"},
+ {"GetMediaHandler", (PyCFunction)MediaObj_GetMediaHandler, 1,
+ "() -> (MediaHandler _rv)"},
+ {"SetMediaHandler", (PyCFunction)MediaObj_SetMediaHandler, 1,
+ "(MediaHandlerComponent mH) -> None"},
+ {"BeginMediaEdits", (PyCFunction)MediaObj_BeginMediaEdits, 1,
+ "() -> None"},
+ {"EndMediaEdits", (PyCFunction)MediaObj_EndMediaEdits, 1,
+ "() -> None"},
+ {"SetMediaDefaultDataRefIndex", (PyCFunction)MediaObj_SetMediaDefaultDataRefIndex, 1,
+ "(short index) -> None"},
+ {"GetMediaDataHandlerDescription", (PyCFunction)MediaObj_GetMediaDataHandlerDescription, 1,
+ "(short index, Str255 creatorName) -> (OSType dhType, OSType creatorManufacturer)"},
+ {"GetMediaDataHandler", (PyCFunction)MediaObj_GetMediaDataHandler, 1,
+ "(short index) -> (DataHandler _rv)"},
+ {"SetMediaDataHandler", (PyCFunction)MediaObj_SetMediaDataHandler, 1,
+ "(short index, DataHandlerComponent dataHandler) -> None"},
+ {"GetMediaSampleDescriptionCount", (PyCFunction)MediaObj_GetMediaSampleDescriptionCount, 1,
+ "() -> (long _rv)"},
+ {"GetMediaSampleDescription", (PyCFunction)MediaObj_GetMediaSampleDescription, 1,
+ "(long index, SampleDescriptionHandle descH) -> None"},
+ {"SetMediaSampleDescription", (PyCFunction)MediaObj_SetMediaSampleDescription, 1,
+ "(long index, SampleDescriptionHandle descH) -> None"},
+ {"GetMediaSampleCount", (PyCFunction)MediaObj_GetMediaSampleCount, 1,
+ "() -> (long _rv)"},
+ {"GetMediaSyncSampleCount", (PyCFunction)MediaObj_GetMediaSyncSampleCount, 1,
+ "() -> (long _rv)"},
+ {"SampleNumToMediaTime", (PyCFunction)MediaObj_SampleNumToMediaTime, 1,
+ "(long logicalSampleNum) -> (TimeValue sampleTime, TimeValue sampleDuration)"},
+ {"MediaTimeToSampleNum", (PyCFunction)MediaObj_MediaTimeToSampleNum, 1,
+ "(TimeValue time) -> (long sampleNum, TimeValue sampleTime, TimeValue sampleDuration)"},
+ {"AddMediaSample", (PyCFunction)MediaObj_AddMediaSample, 1,
+ "(Handle dataIn, long inOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)"},
+ {"AddMediaSampleReference", (PyCFunction)MediaObj_AddMediaSampleReference, 1,
+ "(long dataOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)"},
+ {"GetMediaSample", (PyCFunction)MediaObj_GetMediaSample, 1,
+ "(Handle dataOut, long maxSizeToGrow, TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)"},
+ {"GetMediaSampleReference", (PyCFunction)MediaObj_GetMediaSampleReference, 1,
+ "(TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long dataOffset, long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)"},
+ {"SetMediaPreferredChunkSize", (PyCFunction)MediaObj_SetMediaPreferredChunkSize, 1,
+ "(long maxChunkSize) -> None"},
+ {"GetMediaPreferredChunkSize", (PyCFunction)MediaObj_GetMediaPreferredChunkSize, 1,
+ "() -> (long maxChunkSize)"},
+ {"SetMediaShadowSync", (PyCFunction)MediaObj_SetMediaShadowSync, 1,
+ "(long frameDiffSampleNum, long syncSampleNum) -> None"},
+ {"GetMediaShadowSync", (PyCFunction)MediaObj_GetMediaShadowSync, 1,
+ "(long frameDiffSampleNum) -> (long syncSampleNum)"},
+ {"GetMediaDataSize", (PyCFunction)MediaObj_GetMediaDataSize, 1,
+ "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
+ {"GetMediaDataSize64", (PyCFunction)MediaObj_GetMediaDataSize64, 1,
+ "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
+ {"GetMediaNextInterestingTime", (PyCFunction)MediaObj_GetMediaNextInterestingTime, 1,
+ "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
+ {"GetMediaDataRef", (PyCFunction)MediaObj_GetMediaDataRef, 1,
+ "(short index) -> (Handle dataRef, OSType dataRefType, long dataRefAttributes)"},
+ {"SetMediaDataRef", (PyCFunction)MediaObj_SetMediaDataRef, 1,
+ "(short index, Handle dataRef, OSType dataRefType) -> None"},
+ {"SetMediaDataRefAttributes", (PyCFunction)MediaObj_SetMediaDataRefAttributes, 1,
+ "(short index, long dataRefAttributes) -> None"},
+ {"AddMediaDataRef", (PyCFunction)MediaObj_AddMediaDataRef, 1,
+ "(Handle dataRef, OSType dataRefType) -> (short index)"},
+ {"GetMediaDataRefCount", (PyCFunction)MediaObj_GetMediaDataRefCount, 1,
+ "() -> (short count)"},
+ {"SetMediaPlayHints", (PyCFunction)MediaObj_SetMediaPlayHints, 1,
+ "(long flags, long flagsMask) -> None"},
+ {"GetMediaPlayHints", (PyCFunction)MediaObj_GetMediaPlayHints, 1,
+ "() -> (long flags)"},
+ {"GetMediaNextInterestingTimeOnly", (PyCFunction)MediaObj_GetMediaNextInterestingTimeOnly, 1,
+ "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain MediaObj_chain = { MediaObj_methods, NULL };
+
+static PyObject *MediaObj_getattr(MediaObject *self, char *name)
+{
+ return Py_FindMethodInChain(&MediaObj_chain, (PyObject *)self, name);
+}
+
+#define MediaObj_setattr NULL
+
+#define MediaObj_compare NULL
+
+#define MediaObj_repr NULL
+
+#define MediaObj_hash NULL
+
+PyTypeObject Media_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "Media", /*tp_name*/
+ sizeof(MediaObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) MediaObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) MediaObj_getattr, /*tp_getattr*/
+ (setattrfunc) MediaObj_setattr, /*tp_setattr*/
+ (cmpfunc) MediaObj_compare, /*tp_compare*/
+ (reprfunc) MediaObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) MediaObj_hash, /*tp_hash*/
+};
+
+/* --------------------- End object type Media ---------------------- */
+
+
+/* ----------------------- Object type Track ------------------------ */
+
+PyTypeObject Track_Type;
+
+#define TrackObj_Check(x) ((x)->ob_type == &Track_Type)
+
+typedef struct TrackObject {
+ PyObject_HEAD
+ Track ob_itself;
+} TrackObject;
+
+PyObject *TrackObj_New(Track itself)
+{
+ TrackObject *it;
+ if (itself == NULL) {
+ PyErr_SetString(Qt_Error,"Cannot create null Track");
+ return NULL;
+ }
+ it = PyObject_NEW(TrackObject, &Track_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+TrackObj_Convert(PyObject *v, Track *p_itself)
+{
+ if (!TrackObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "Track required");
+ return 0;
+ }
+ *p_itself = ((TrackObject *)v)->ob_itself;
+ return 1;
+}
+
+static void TrackObj_dealloc(TrackObject *self)
+{
+ DisposeMovieTrack(self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *TrackObj_LoadTrackIntoRam(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue time;
+ TimeValue duration;
+ long flags;
+ if (!PyArg_ParseTuple(_args, "lll",
+ &time,
+ &duration,
+ &flags))
+ return NULL;
+ _err = LoadTrackIntoRam(_self->ob_itself,
+ time,
+ duration,
+ flags);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackPict(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PicHandle _rv;
+ TimeValue time;
+ if (!PyArg_ParseTuple(_args, "l",
+ &time))
+ return NULL;
+ _rv = GetTrackPict(_self->ob_itself,
+ time);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackClipRgn(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackClipRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_SetTrackClipRgn(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle theClip;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theClip))
+ return NULL;
+ SetTrackClipRgn(_self->ob_itself,
+ theClip);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackDisplayBoundsRgn(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackDisplayBoundsRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackMovieBoundsRgn(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackMovieBoundsRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackBoundsRgn(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackBoundsRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackMatte(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackMatte(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_SetTrackMatte(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle theMatte;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theMatte))
+ return NULL;
+ SetTrackMatte(_self->ob_itself,
+ theMatte);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackID(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackID(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackMovie(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Movie _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackMovie(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackCreationTime(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ unsigned long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackCreationTime(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackModificationTime(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ unsigned long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackModificationTime(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackEnabled(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackEnabled(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_SetTrackEnabled(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean isEnabled;
+ if (!PyArg_ParseTuple(_args, "b",
+ &isEnabled))
+ return NULL;
+ SetTrackEnabled(_self->ob_itself,
+ isEnabled);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackUsage(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackUsage(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_SetTrackUsage(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long usage;
+ if (!PyArg_ParseTuple(_args, "l",
+ &usage))
+ return NULL;
+ SetTrackUsage(_self->ob_itself,
+ usage);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackDuration(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackDuration(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackOffset(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackOffset(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_SetTrackOffset(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue movieOffsetTime;
+ if (!PyArg_ParseTuple(_args, "l",
+ &movieOffsetTime))
+ return NULL;
+ SetTrackOffset(_self->ob_itself,
+ movieOffsetTime);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackLayer(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackLayer(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_SetTrackLayer(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short layer;
+ if (!PyArg_ParseTuple(_args, "h",
+ &layer))
+ return NULL;
+ SetTrackLayer(_self->ob_itself,
+ layer);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackAlternate(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Track _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackAlternate(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ TrackObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_SetTrackAlternate(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Track alternateT;
+ if (!PyArg_ParseTuple(_args, "O&",
+ TrackObj_Convert, &alternateT))
+ return NULL;
+ SetTrackAlternate(_self->ob_itself,
+ alternateT);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackVolume(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackVolume(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_SetTrackVolume(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short volume;
+ if (!PyArg_ParseTuple(_args, "h",
+ &volume))
+ return NULL;
+ SetTrackVolume(_self->ob_itself,
+ volume);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackDimensions(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Fixed width;
+ Fixed height;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetTrackDimensions(_self->ob_itself,
+ &width,
+ &height);
+ _res = Py_BuildValue("O&O&",
+ PyMac_BuildFixed, width,
+ PyMac_BuildFixed, height);
+ return _res;
+}
+
+static PyObject *TrackObj_SetTrackDimensions(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Fixed width;
+ Fixed height;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetFixed, &width,
+ PyMac_GetFixed, &height))
+ return NULL;
+ SetTrackDimensions(_self->ob_itself,
+ width,
+ height);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackUserData(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UserData _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackUserData(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ UserDataObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackSoundLocalizationSettings(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle settings;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetTrackSoundLocalizationSettings(_self->ob_itself,
+ &settings);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, settings);
+ return _res;
+}
+
+static PyObject *TrackObj_SetTrackSoundLocalizationSettings(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle settings;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &settings))
+ return NULL;
+ _err = SetTrackSoundLocalizationSettings(_self->ob_itself,
+ settings);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_NewTrackMedia(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Media _rv;
+ OSType mediaType;
+ TimeScale timeScale;
+ Handle dataRef;
+ OSType dataRefType;
+ if (!PyArg_ParseTuple(_args, "O&lO&O&",
+ PyMac_GetOSType, &mediaType,
+ &timeScale,
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
+ return NULL;
+ _rv = NewTrackMedia(_self->ob_itself,
+ mediaType,
+ timeScale,
+ dataRef,
+ dataRefType);
+ _res = Py_BuildValue("O&",
+ MediaObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackMedia(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Media _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackMedia(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ MediaObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_InsertMediaIntoTrack(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue trackStart;
+ TimeValue mediaTime;
+ TimeValue mediaDuration;
+ Fixed mediaRate;
+ if (!PyArg_ParseTuple(_args, "lllO&",
+ &trackStart,
+ &mediaTime,
+ &mediaDuration,
+ PyMac_GetFixed, &mediaRate))
+ return NULL;
+ _err = InsertMediaIntoTrack(_self->ob_itself,
+ trackStart,
+ mediaTime,
+ mediaDuration,
+ mediaRate);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_InsertTrackSegment(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Track dstTrack;
+ TimeValue srcIn;
+ TimeValue srcDuration;
+ TimeValue dstIn;
+ if (!PyArg_ParseTuple(_args, "O&lll",
+ TrackObj_Convert, &dstTrack,
+ &srcIn,
+ &srcDuration,
+ &dstIn))
+ return NULL;
+ _err = InsertTrackSegment(_self->ob_itself,
+ dstTrack,
+ srcIn,
+ srcDuration,
+ dstIn);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_InsertEmptyTrackSegment(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue dstIn;
+ TimeValue dstDuration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &dstIn,
+ &dstDuration))
+ return NULL;
+ _err = InsertEmptyTrackSegment(_self->ob_itself,
+ dstIn,
+ dstDuration);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_DeleteTrackSegment(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue startTime;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
+ return NULL;
+ _err = DeleteTrackSegment(_self->ob_itself,
+ startTime,
+ duration);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_ScaleTrackSegment(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue startTime;
+ TimeValue oldDuration;
+ TimeValue newDuration;
+ if (!PyArg_ParseTuple(_args, "lll",
+ &startTime,
+ &oldDuration,
+ &newDuration))
+ return NULL;
+ _err = ScaleTrackSegment(_self->ob_itself,
+ startTime,
+ oldDuration,
+ newDuration);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_IsScrapMovie(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Component _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsScrapMovie(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CmpObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_CopyTrackSettings(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Track dstTrack;
+ if (!PyArg_ParseTuple(_args, "O&",
+ TrackObj_Convert, &dstTrack))
+ return NULL;
+ _err = CopyTrackSettings(_self->ob_itself,
+ dstTrack);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_AddEmptyTrackToMovie(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Movie dstMovie;
+ Handle dataRef;
+ OSType dataRefType;
+ Track dstTrack;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ MovieObj_Convert, &dstMovie,
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
+ return NULL;
+ _err = AddEmptyTrackToMovie(_self->ob_itself,
+ dstMovie,
+ dataRef,
+ dataRefType,
+ &dstTrack);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ TrackObj_New, dstTrack);
+ return _res;
+}
+
+static PyObject *TrackObj_AddTrackReference(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Track refTrack;
+ OSType refType;
+ long addedIndex;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ TrackObj_Convert, &refTrack,
+ PyMac_GetOSType, &refType))
+ return NULL;
+ _err = AddTrackReference(_self->ob_itself,
+ refTrack,
+ refType,
+ &addedIndex);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ addedIndex);
+ return _res;
+}
+
+static PyObject *TrackObj_DeleteTrackReference(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType refType;
+ long index;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetOSType, &refType,
+ &index))
+ return NULL;
+ _err = DeleteTrackReference(_self->ob_itself,
+ refType,
+ index);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_SetTrackReference(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Track refTrack;
+ OSType refType;
+ long index;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ TrackObj_Convert, &refTrack,
+ PyMac_GetOSType, &refType,
+ &index))
+ return NULL;
+ _err = SetTrackReference(_self->ob_itself,
+ refTrack,
+ refType,
+ index);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackReference(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Track _rv;
+ OSType refType;
+ long index;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetOSType, &refType,
+ &index))
+ return NULL;
+ _rv = GetTrackReference(_self->ob_itself,
+ refType,
+ index);
+ _res = Py_BuildValue("O&",
+ TrackObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetNextTrackReferenceType(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSType _rv;
+ OSType refType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &refType))
+ return NULL;
+ _rv = GetNextTrackReferenceType(_self->ob_itself,
+ refType);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildOSType, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackReferenceCount(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ OSType refType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &refType))
+ return NULL;
+ _rv = GetTrackReferenceCount(_self->ob_itself,
+ refType);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackEditRate(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Fixed _rv;
+ TimeValue atTime;
+ if (!PyArg_ParseTuple(_args, "l",
+ &atTime))
+ return NULL;
+ _rv = GetTrackEditRate(_self->ob_itself,
+ atTime);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildFixed, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackDataSize(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ TimeValue startTime;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
+ return NULL;
+ _rv = GetTrackDataSize(_self->ob_itself,
+ startTime,
+ duration);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackDataSize64(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue startTime;
+ TimeValue duration;
+ wide dataSize;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
+ return NULL;
+ _err = GetTrackDataSize64(_self->ob_itself,
+ startTime,
+ duration,
+ &dataSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_Buildwide, dataSize);
+ return _res;
+}
+
+static PyObject *TrackObj_PtInTrack(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point pt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &pt))
+ return NULL;
+ _rv = PtInTrack(_self->ob_itself,
+ pt);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackNextInterestingTime(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short interestingTimeFlags;
+ TimeValue time;
+ Fixed rate;
+ TimeValue interestingTime;
+ TimeValue interestingDuration;
+ if (!PyArg_ParseTuple(_args, "hlO&",
+ &interestingTimeFlags,
+ &time,
+ PyMac_GetFixed, &rate))
+ return NULL;
+ GetTrackNextInterestingTime(_self->ob_itself,
+ interestingTimeFlags,
+ time,
+ rate,
+ &interestingTime,
+ &interestingDuration);
+ _res = Py_BuildValue("ll",
+ interestingTime,
+ interestingDuration);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackSegmentDisplayBoundsRgn(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ TimeValue time;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &time,
+ &duration))
+ return NULL;
+ _rv = GetTrackSegmentDisplayBoundsRgn(_self->ob_itself,
+ time,
+ duration);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackStatus(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTrackStatus(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TrackObj_SetTrackLoadSettings(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue preloadTime;
+ TimeValue preloadDuration;
+ long preloadFlags;
+ long defaultHints;
+ if (!PyArg_ParseTuple(_args, "llll",
+ &preloadTime,
+ &preloadDuration,
+ &preloadFlags,
+ &defaultHints))
+ return NULL;
+ SetTrackLoadSettings(_self->ob_itself,
+ preloadTime,
+ preloadDuration,
+ preloadFlags,
+ defaultHints);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TrackObj_GetTrackLoadSettings(TrackObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue preloadTime;
+ TimeValue preloadDuration;
+ long preloadFlags;
+ long defaultHints;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetTrackLoadSettings(_self->ob_itself,
+ &preloadTime,
+ &preloadDuration,
+ &preloadFlags,
+ &defaultHints);
+ _res = Py_BuildValue("llll",
+ preloadTime,
+ preloadDuration,
+ preloadFlags,
+ defaultHints);
+ return _res;
+}
+
+static PyMethodDef TrackObj_methods[] = {
+ {"LoadTrackIntoRam", (PyCFunction)TrackObj_LoadTrackIntoRam, 1,
+ "(TimeValue time, TimeValue duration, long flags) -> None"},
+ {"GetTrackPict", (PyCFunction)TrackObj_GetTrackPict, 1,
+ "(TimeValue time) -> (PicHandle _rv)"},
+ {"GetTrackClipRgn", (PyCFunction)TrackObj_GetTrackClipRgn, 1,
+ "() -> (RgnHandle _rv)"},
+ {"SetTrackClipRgn", (PyCFunction)TrackObj_SetTrackClipRgn, 1,
+ "(RgnHandle theClip) -> None"},
+ {"GetTrackDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackDisplayBoundsRgn, 1,
+ "() -> (RgnHandle _rv)"},
+ {"GetTrackMovieBoundsRgn", (PyCFunction)TrackObj_GetTrackMovieBoundsRgn, 1,
+ "() -> (RgnHandle _rv)"},
+ {"GetTrackBoundsRgn", (PyCFunction)TrackObj_GetTrackBoundsRgn, 1,
+ "() -> (RgnHandle _rv)"},
+ {"GetTrackMatte", (PyCFunction)TrackObj_GetTrackMatte, 1,
+ "() -> (PixMapHandle _rv)"},
+ {"SetTrackMatte", (PyCFunction)TrackObj_SetTrackMatte, 1,
+ "(PixMapHandle theMatte) -> None"},
+ {"GetTrackID", (PyCFunction)TrackObj_GetTrackID, 1,
+ "() -> (long _rv)"},
+ {"GetTrackMovie", (PyCFunction)TrackObj_GetTrackMovie, 1,
+ "() -> (Movie _rv)"},
+ {"GetTrackCreationTime", (PyCFunction)TrackObj_GetTrackCreationTime, 1,
+ "() -> (unsigned long _rv)"},
+ {"GetTrackModificationTime", (PyCFunction)TrackObj_GetTrackModificationTime, 1,
+ "() -> (unsigned long _rv)"},
+ {"GetTrackEnabled", (PyCFunction)TrackObj_GetTrackEnabled, 1,
+ "() -> (Boolean _rv)"},
+ {"SetTrackEnabled", (PyCFunction)TrackObj_SetTrackEnabled, 1,
+ "(Boolean isEnabled) -> None"},
+ {"GetTrackUsage", (PyCFunction)TrackObj_GetTrackUsage, 1,
+ "() -> (long _rv)"},
+ {"SetTrackUsage", (PyCFunction)TrackObj_SetTrackUsage, 1,
+ "(long usage) -> None"},
+ {"GetTrackDuration", (PyCFunction)TrackObj_GetTrackDuration, 1,
+ "() -> (TimeValue _rv)"},
+ {"GetTrackOffset", (PyCFunction)TrackObj_GetTrackOffset, 1,
+ "() -> (TimeValue _rv)"},
+ {"SetTrackOffset", (PyCFunction)TrackObj_SetTrackOffset, 1,
+ "(TimeValue movieOffsetTime) -> None"},
+ {"GetTrackLayer", (PyCFunction)TrackObj_GetTrackLayer, 1,
+ "() -> (short _rv)"},
+ {"SetTrackLayer", (PyCFunction)TrackObj_SetTrackLayer, 1,
+ "(short layer) -> None"},
+ {"GetTrackAlternate", (PyCFunction)TrackObj_GetTrackAlternate, 1,
+ "() -> (Track _rv)"},
+ {"SetTrackAlternate", (PyCFunction)TrackObj_SetTrackAlternate, 1,
+ "(Track alternateT) -> None"},
+ {"GetTrackVolume", (PyCFunction)TrackObj_GetTrackVolume, 1,
+ "() -> (short _rv)"},
+ {"SetTrackVolume", (PyCFunction)TrackObj_SetTrackVolume, 1,
+ "(short volume) -> None"},
+ {"GetTrackDimensions", (PyCFunction)TrackObj_GetTrackDimensions, 1,
+ "() -> (Fixed width, Fixed height)"},
+ {"SetTrackDimensions", (PyCFunction)TrackObj_SetTrackDimensions, 1,
+ "(Fixed width, Fixed height) -> None"},
+ {"GetTrackUserData", (PyCFunction)TrackObj_GetTrackUserData, 1,
+ "() -> (UserData _rv)"},
+ {"GetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_GetTrackSoundLocalizationSettings, 1,
+ "() -> (Handle settings)"},
+ {"SetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_SetTrackSoundLocalizationSettings, 1,
+ "(Handle settings) -> None"},
+ {"NewTrackMedia", (PyCFunction)TrackObj_NewTrackMedia, 1,
+ "(OSType mediaType, TimeScale timeScale, Handle dataRef, OSType dataRefType) -> (Media _rv)"},
+ {"GetTrackMedia", (PyCFunction)TrackObj_GetTrackMedia, 1,
+ "() -> (Media _rv)"},
+ {"InsertMediaIntoTrack", (PyCFunction)TrackObj_InsertMediaIntoTrack, 1,
+ "(TimeValue trackStart, TimeValue mediaTime, TimeValue mediaDuration, Fixed mediaRate) -> None"},
+ {"InsertTrackSegment", (PyCFunction)TrackObj_InsertTrackSegment, 1,
+ "(Track dstTrack, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None"},
+ {"InsertEmptyTrackSegment", (PyCFunction)TrackObj_InsertEmptyTrackSegment, 1,
+ "(TimeValue dstIn, TimeValue dstDuration) -> None"},
+ {"DeleteTrackSegment", (PyCFunction)TrackObj_DeleteTrackSegment, 1,
+ "(TimeValue startTime, TimeValue duration) -> None"},
+ {"ScaleTrackSegment", (PyCFunction)TrackObj_ScaleTrackSegment, 1,
+ "(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None"},
+ {"IsScrapMovie", (PyCFunction)TrackObj_IsScrapMovie, 1,
+ "() -> (Component _rv)"},
+ {"CopyTrackSettings", (PyCFunction)TrackObj_CopyTrackSettings, 1,
+ "(Track dstTrack) -> None"},
+ {"AddEmptyTrackToMovie", (PyCFunction)TrackObj_AddEmptyTrackToMovie, 1,
+ "(Movie dstMovie, Handle dataRef, OSType dataRefType) -> (Track dstTrack)"},
+ {"AddTrackReference", (PyCFunction)TrackObj_AddTrackReference, 1,
+ "(Track refTrack, OSType refType) -> (long addedIndex)"},
+ {"DeleteTrackReference", (PyCFunction)TrackObj_DeleteTrackReference, 1,
+ "(OSType refType, long index) -> None"},
+ {"SetTrackReference", (PyCFunction)TrackObj_SetTrackReference, 1,
+ "(Track refTrack, OSType refType, long index) -> None"},
+ {"GetTrackReference", (PyCFunction)TrackObj_GetTrackReference, 1,
+ "(OSType refType, long index) -> (Track _rv)"},
+ {"GetNextTrackReferenceType", (PyCFunction)TrackObj_GetNextTrackReferenceType, 1,
+ "(OSType refType) -> (OSType _rv)"},
+ {"GetTrackReferenceCount", (PyCFunction)TrackObj_GetTrackReferenceCount, 1,
+ "(OSType refType) -> (long _rv)"},
+ {"GetTrackEditRate", (PyCFunction)TrackObj_GetTrackEditRate, 1,
+ "(TimeValue atTime) -> (Fixed _rv)"},
+ {"GetTrackDataSize", (PyCFunction)TrackObj_GetTrackDataSize, 1,
+ "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
+ {"GetTrackDataSize64", (PyCFunction)TrackObj_GetTrackDataSize64, 1,
+ "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
+ {"PtInTrack", (PyCFunction)TrackObj_PtInTrack, 1,
+ "(Point pt) -> (Boolean _rv)"},
+ {"GetTrackNextInterestingTime", (PyCFunction)TrackObj_GetTrackNextInterestingTime, 1,
+ "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
+ {"GetTrackSegmentDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackSegmentDisplayBoundsRgn, 1,
+ "(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"},
+ {"GetTrackStatus", (PyCFunction)TrackObj_GetTrackStatus, 1,
+ "() -> (ComponentResult _rv)"},
+ {"SetTrackLoadSettings", (PyCFunction)TrackObj_SetTrackLoadSettings, 1,
+ "(TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints) -> None"},
+ {"GetTrackLoadSettings", (PyCFunction)TrackObj_GetTrackLoadSettings, 1,
+ "() -> (TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain TrackObj_chain = { TrackObj_methods, NULL };
+
+static PyObject *TrackObj_getattr(TrackObject *self, char *name)
+{
+ return Py_FindMethodInChain(&TrackObj_chain, (PyObject *)self, name);
+}
+
+#define TrackObj_setattr NULL
+
+#define TrackObj_compare NULL
+
+#define TrackObj_repr NULL
+
+#define TrackObj_hash NULL
+
+PyTypeObject Track_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "Track", /*tp_name*/
+ sizeof(TrackObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) TrackObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) TrackObj_getattr, /*tp_getattr*/
+ (setattrfunc) TrackObj_setattr, /*tp_setattr*/
+ (cmpfunc) TrackObj_compare, /*tp_compare*/
+ (reprfunc) TrackObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) TrackObj_hash, /*tp_hash*/
+};
+
+/* --------------------- End object type Track ---------------------- */
+
+
+/* ----------------------- Object type Movie ------------------------ */
+
+PyTypeObject Movie_Type;
+
+#define MovieObj_Check(x) ((x)->ob_type == &Movie_Type)
+
+typedef struct MovieObject {
+ PyObject_HEAD
+ Movie ob_itself;
+} MovieObject;
+
+PyObject *MovieObj_New(Movie itself)
+{
+ MovieObject *it;
+ if (itself == NULL) {
+ PyErr_SetString(Qt_Error,"Cannot create null Movie");
+ return NULL;
+ }
+ it = PyObject_NEW(MovieObject, &Movie_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+MovieObj_Convert(PyObject *v, Movie *p_itself)
+{
+ if (!MovieObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "Movie required");
+ return 0;
+ }
+ *p_itself = ((MovieObject *)v)->ob_itself;
+ return 1;
+}
+
+static void MovieObj_dealloc(MovieObject *self)
+{
+ DisposeMovie(self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *MovieObj_MoviesTask(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long maxMilliSecToUse;
+ if (!PyArg_ParseTuple(_args, "l",
+ &maxMilliSecToUse))
+ return NULL;
+ MoviesTask(_self->ob_itself,
+ maxMilliSecToUse);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_PrerollMovie(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue time;
+ Fixed Rate;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &time,
+ PyMac_GetFixed, &Rate))
+ return NULL;
+ _err = PrerollMovie(_self->ob_itself,
+ time,
+ Rate);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_AbortPrePrerollMovie(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr err;
+ if (!PyArg_ParseTuple(_args, "h",
+ &err))
+ return NULL;
+ AbortPrePrerollMovie(_self->ob_itself,
+ err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_LoadMovieIntoRam(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue time;
+ TimeValue duration;
+ long flags;
+ if (!PyArg_ParseTuple(_args, "lll",
+ &time,
+ &duration,
+ &flags))
+ return NULL;
+ _err = LoadMovieIntoRam(_self->ob_itself,
+ time,
+ duration,
+ flags);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieActive(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean active;
+ if (!PyArg_ParseTuple(_args, "b",
+ &active))
+ return NULL;
+ SetMovieActive(_self->ob_itself,
+ active);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieActive(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieActive(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_StartMovie(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ StartMovie(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_StopMovie(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ StopMovie(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GoToBeginningOfMovie(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GoToBeginningOfMovie(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GoToEndOfMovie(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GoToEndOfMovie(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_IsMovieDone(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsMovieDone(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMoviePreviewMode(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMoviePreviewMode(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMoviePreviewMode(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean usePreview;
+ if (!PyArg_ParseTuple(_args, "b",
+ &usePreview))
+ return NULL;
+ SetMoviePreviewMode(_self->ob_itself,
+ usePreview);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_ShowMoviePoster(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ShowMoviePoster(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieTimeBase(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeBase _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieTimeBase(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ TimeBaseObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieMasterTimeBase(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeBase tb;
+ TimeRecord slaveZero;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ TimeBaseObj_Convert, &tb,
+ QtTimeRecord_Convert, &slaveZero))
+ return NULL;
+ SetMovieMasterTimeBase(_self->ob_itself,
+ tb,
+ &slaveZero);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieMasterClock(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Component clockMeister;
+ TimeRecord slaveZero;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ CmpObj_Convert, &clockMeister,
+ QtTimeRecord_Convert, &slaveZero))
+ return NULL;
+ SetMovieMasterClock(_self->ob_itself,
+ clockMeister,
+ &slaveZero);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieGWorld(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ GDHandle gdh;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetMovieGWorld(_self->ob_itself,
+ &port,
+ &gdh);
+ _res = Py_BuildValue("O&O&",
+ GrafObj_New, port,
+ OptResObj_New, gdh);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieGWorld(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr port;
+ GDHandle gdh;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ GrafObj_Convert, &port,
+ OptResObj_Convert, &gdh))
+ return NULL;
+ SetMovieGWorld(_self->ob_itself,
+ port,
+ gdh);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieNaturalBoundsRect(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect naturalBounds;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetMovieNaturalBoundsRect(_self->ob_itself,
+ &naturalBounds);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &naturalBounds);
+ return _res;
+}
+
+static PyObject *MovieObj_GetNextTrackForCompositing(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Track _rv;
+ Track theTrack;
+ if (!PyArg_ParseTuple(_args, "O&",
+ TrackObj_Convert, &theTrack))
+ return NULL;
+ _rv = GetNextTrackForCompositing(_self->ob_itself,
+ theTrack);
+ _res = Py_BuildValue("O&",
+ TrackObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetPrevTrackForCompositing(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Track _rv;
+ Track theTrack;
+ if (!PyArg_ParseTuple(_args, "O&",
+ TrackObj_Convert, &theTrack))
+ return NULL;
+ _rv = GetPrevTrackForCompositing(_self->ob_itself,
+ theTrack);
+ _res = Py_BuildValue("O&",
+ TrackObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMoviePict(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PicHandle _rv;
+ TimeValue time;
+ if (!PyArg_ParseTuple(_args, "l",
+ &time))
+ return NULL;
+ _rv = GetMoviePict(_self->ob_itself,
+ time);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMoviePosterPict(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PicHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMoviePosterPict(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_UpdateMovie(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = UpdateMovie(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_InvalidateMovieRegion(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ RgnHandle invalidRgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &invalidRgn))
+ return NULL;
+ _err = InvalidateMovieRegion(_self->ob_itself,
+ invalidRgn);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieBox(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect boxRect;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetMovieBox(_self->ob_itself,
+ &boxRect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &boxRect);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieBox(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect boxRect;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &boxRect))
+ return NULL;
+ SetMovieBox(_self->ob_itself,
+ &boxRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieDisplayClipRgn(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieDisplayClipRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieDisplayClipRgn(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle theClip;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theClip))
+ return NULL;
+ SetMovieDisplayClipRgn(_self->ob_itself,
+ theClip);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieClipRgn(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieClipRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieClipRgn(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle theClip;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theClip))
+ return NULL;
+ SetMovieClipRgn(_self->ob_itself,
+ theClip);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieDisplayBoundsRgn(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieDisplayBoundsRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieBoundsRgn(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieBoundsRgn(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_PutMovieIntoHandle(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle publicMovie;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &publicMovie))
+ return NULL;
+ _err = PutMovieIntoHandle(_self->ob_itself,
+ publicMovie);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_PutMovieIntoDataFork(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short fRefNum;
+ long offset;
+ long maxSize;
+ if (!PyArg_ParseTuple(_args, "hll",
+ &fRefNum,
+ &offset,
+ &maxSize))
+ return NULL;
+ _err = PutMovieIntoDataFork(_self->ob_itself,
+ fRefNum,
+ offset,
+ maxSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_PutMovieIntoDataFork64(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long fRefNum;
+ wide offset;
+ unsigned long maxSize;
+ if (!PyArg_ParseTuple(_args, "lO&l",
+ &fRefNum,
+ PyMac_Getwide, &offset,
+ &maxSize))
+ return NULL;
+ _err = PutMovieIntoDataFork64(_self->ob_itself,
+ fRefNum,
+ &offset,
+ maxSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieCreationTime(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ unsigned long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieCreationTime(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieModificationTime(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ unsigned long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieModificationTime(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieTimeScale(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeScale _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieTimeScale(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieTimeScale(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeScale timeScale;
+ if (!PyArg_ParseTuple(_args, "l",
+ &timeScale))
+ return NULL;
+ SetMovieTimeScale(_self->ob_itself,
+ timeScale);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieDuration(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieDuration(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieRate(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Fixed _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieRate(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildFixed, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieRate(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Fixed rate;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFixed, &rate))
+ return NULL;
+ SetMovieRate(_self->ob_itself,
+ rate);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMoviePreferredRate(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Fixed _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMoviePreferredRate(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildFixed, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMoviePreferredRate(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Fixed rate;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFixed, &rate))
+ return NULL;
+ SetMoviePreferredRate(_self->ob_itself,
+ rate);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMoviePreferredVolume(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMoviePreferredVolume(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMoviePreferredVolume(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short volume;
+ if (!PyArg_ParseTuple(_args, "h",
+ &volume))
+ return NULL;
+ SetMoviePreferredVolume(_self->ob_itself,
+ volume);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieVolume(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieVolume(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieVolume(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short volume;
+ if (!PyArg_ParseTuple(_args, "h",
+ &volume))
+ return NULL;
+ SetMovieVolume(_self->ob_itself,
+ volume);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMoviePreviewTime(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue previewTime;
+ TimeValue previewDuration;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetMoviePreviewTime(_self->ob_itself,
+ &previewTime,
+ &previewDuration);
+ _res = Py_BuildValue("ll",
+ previewTime,
+ previewDuration);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMoviePreviewTime(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue previewTime;
+ TimeValue previewDuration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &previewTime,
+ &previewDuration))
+ return NULL;
+ SetMoviePreviewTime(_self->ob_itself,
+ previewTime,
+ previewDuration);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMoviePosterTime(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMoviePosterTime(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMoviePosterTime(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue posterTime;
+ if (!PyArg_ParseTuple(_args, "l",
+ &posterTime))
+ return NULL;
+ SetMoviePosterTime(_self->ob_itself,
+ posterTime);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieSelection(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue selectionTime;
+ TimeValue selectionDuration;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetMovieSelection(_self->ob_itself,
+ &selectionTime,
+ &selectionDuration);
+ _res = Py_BuildValue("ll",
+ selectionTime,
+ selectionDuration);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieSelection(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue selectionTime;
+ TimeValue selectionDuration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &selectionTime,
+ &selectionDuration))
+ return NULL;
+ SetMovieSelection(_self->ob_itself,
+ selectionTime,
+ selectionDuration);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieActiveSegment(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue startTime;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
+ return NULL;
+ SetMovieActiveSegment(_self->ob_itself,
+ startTime,
+ duration);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieActiveSegment(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue startTime;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetMovieActiveSegment(_self->ob_itself,
+ &startTime,
+ &duration);
+ _res = Py_BuildValue("ll",
+ startTime,
+ duration);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieTime(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue _rv;
+ TimeRecord currentTime;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieTime(_self->ob_itself,
+ ¤tTime);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ QtTimeRecord_New, ¤tTime);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieTime(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeRecord newtime;
+ if (!PyArg_ParseTuple(_args, "O&",
+ QtTimeRecord_Convert, &newtime))
+ return NULL;
+ SetMovieTime(_self->ob_itself,
+ &newtime);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieTimeValue(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue newtime;
+ if (!PyArg_ParseTuple(_args, "l",
+ &newtime))
+ return NULL;
+ SetMovieTimeValue(_self->ob_itself,
+ newtime);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieUserData(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UserData _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieUserData(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ UserDataObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieTrackCount(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieTrackCount(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieTrack(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Track _rv;
+ long trackID;
+ if (!PyArg_ParseTuple(_args, "l",
+ &trackID))
+ return NULL;
+ _rv = GetMovieTrack(_self->ob_itself,
+ trackID);
+ _res = Py_BuildValue("O&",
+ TrackObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieIndTrack(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Track _rv;
+ long index;
+ if (!PyArg_ParseTuple(_args, "l",
+ &index))
+ return NULL;
+ _rv = GetMovieIndTrack(_self->ob_itself,
+ index);
+ _res = Py_BuildValue("O&",
+ TrackObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieIndTrackType(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Track _rv;
+ long index;
+ OSType trackType;
+ long flags;
+ if (!PyArg_ParseTuple(_args, "lO&l",
+ &index,
+ PyMac_GetOSType, &trackType,
+ &flags))
+ return NULL;
+ _rv = GetMovieIndTrackType(_self->ob_itself,
+ index,
+ trackType,
+ flags);
+ _res = Py_BuildValue("O&",
+ TrackObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_NewMovieTrack(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Track _rv;
+ Fixed width;
+ Fixed height;
+ short trackVolume;
+ if (!PyArg_ParseTuple(_args, "O&O&h",
+ PyMac_GetFixed, &width,
+ PyMac_GetFixed, &height,
+ &trackVolume))
+ return NULL;
+ _rv = NewMovieTrack(_self->ob_itself,
+ width,
+ height,
+ trackVolume);
+ _res = Py_BuildValue("O&",
+ TrackObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_SetAutoTrackAlternatesEnabled(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean enable;
+ if (!PyArg_ParseTuple(_args, "b",
+ &enable))
+ return NULL;
+ SetAutoTrackAlternatesEnabled(_self->ob_itself,
+ enable);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_SelectMovieAlternates(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ SelectMovieAlternates(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_InsertMovieSegment(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Movie dstMovie;
+ TimeValue srcIn;
+ TimeValue srcDuration;
+ TimeValue dstIn;
+ if (!PyArg_ParseTuple(_args, "O&lll",
+ MovieObj_Convert, &dstMovie,
+ &srcIn,
+ &srcDuration,
+ &dstIn))
+ return NULL;
+ _err = InsertMovieSegment(_self->ob_itself,
+ dstMovie,
+ srcIn,
+ srcDuration,
+ dstIn);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_InsertEmptyMovieSegment(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue dstIn;
+ TimeValue dstDuration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &dstIn,
+ &dstDuration))
+ return NULL;
+ _err = InsertEmptyMovieSegment(_self->ob_itself,
+ dstIn,
+ dstDuration);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_DeleteMovieSegment(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue startTime;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
+ return NULL;
+ _err = DeleteMovieSegment(_self->ob_itself,
+ startTime,
+ duration);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_ScaleMovieSegment(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue startTime;
+ TimeValue oldDuration;
+ TimeValue newDuration;
+ if (!PyArg_ParseTuple(_args, "lll",
+ &startTime,
+ &oldDuration,
+ &newDuration))
+ return NULL;
+ _err = ScaleMovieSegment(_self->ob_itself,
+ startTime,
+ oldDuration,
+ newDuration);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_CutMovieSelection(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Movie _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CutMovieSelection(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_CopyMovieSelection(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Movie _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CopyMovieSelection(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_PasteMovieSelection(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Movie src;
+ if (!PyArg_ParseTuple(_args, "O&",
+ MovieObj_Convert, &src))
+ return NULL;
+ PasteMovieSelection(_self->ob_itself,
+ src);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_AddMovieSelection(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Movie src;
+ if (!PyArg_ParseTuple(_args, "O&",
+ MovieObj_Convert, &src))
+ return NULL;
+ AddMovieSelection(_self->ob_itself,
+ src);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_ClearMovieSelection(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ClearMovieSelection(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_PutMovieIntoTypedHandle(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Track targetTrack;
+ OSType handleType;
+ Handle publicMovie;
+ TimeValue start;
+ TimeValue dur;
+ long flags;
+ ComponentInstance userComp;
+ if (!PyArg_ParseTuple(_args, "O&O&O&lllO&",
+ TrackObj_Convert, &targetTrack,
+ PyMac_GetOSType, &handleType,
+ ResObj_Convert, &publicMovie,
+ &start,
+ &dur,
+ &flags,
+ CmpInstObj_Convert, &userComp))
+ return NULL;
+ _err = PutMovieIntoTypedHandle(_self->ob_itself,
+ targetTrack,
+ handleType,
+ publicMovie,
+ start,
+ dur,
+ flags,
+ userComp);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_CopyMovieSettings(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Movie dstMovie;
+ if (!PyArg_ParseTuple(_args, "O&",
+ MovieObj_Convert, &dstMovie))
+ return NULL;
+ _err = CopyMovieSettings(_self->ob_itself,
+ dstMovie);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_ConvertMovieToFile(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Track onlyTrack;
+ FSSpec outputFile;
+ OSType fileType;
+ OSType creator;
+ ScriptCode scriptTag;
+ short resID;
+ long flags;
+ ComponentInstance userComp;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&hlO&",
+ TrackObj_Convert, &onlyTrack,
+ PyMac_GetFSSpec, &outputFile,
+ PyMac_GetOSType, &fileType,
+ PyMac_GetOSType, &creator,
+ &scriptTag,
+ &flags,
+ CmpInstObj_Convert, &userComp))
+ return NULL;
+ _err = ConvertMovieToFile(_self->ob_itself,
+ onlyTrack,
+ &outputFile,
+ fileType,
+ creator,
+ scriptTag,
+ &resID,
+ flags,
+ userComp);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ resID);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieDataSize(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ TimeValue startTime;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
+ return NULL;
+ _rv = GetMovieDataSize(_self->ob_itself,
+ startTime,
+ duration);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieDataSize64(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue startTime;
+ TimeValue duration;
+ wide dataSize;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &startTime,
+ &duration))
+ return NULL;
+ _err = GetMovieDataSize64(_self->ob_itself,
+ startTime,
+ duration,
+ &dataSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_Buildwide, dataSize);
+ return _res;
+}
+
+static PyObject *MovieObj_PtInMovie(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point pt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &pt))
+ return NULL;
+ _rv = PtInMovie(_self->ob_itself,
+ pt);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieLanguage(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long language;
+ if (!PyArg_ParseTuple(_args, "l",
+ &language))
+ return NULL;
+ SetMovieLanguage(_self->ob_itself,
+ language);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieNextInterestingTime(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short interestingTimeFlags;
+ short numMediaTypes;
+ OSType whichMediaTypes;
+ TimeValue time;
+ Fixed rate;
+ TimeValue interestingTime;
+ TimeValue interestingDuration;
+ if (!PyArg_ParseTuple(_args, "hhO&lO&",
+ &interestingTimeFlags,
+ &numMediaTypes,
+ PyMac_GetOSType, &whichMediaTypes,
+ &time,
+ PyMac_GetFixed, &rate))
+ return NULL;
+ GetMovieNextInterestingTime(_self->ob_itself,
+ interestingTimeFlags,
+ numMediaTypes,
+ &whichMediaTypes,
+ time,
+ rate,
+ &interestingTime,
+ &interestingDuration);
+ _res = Py_BuildValue("ll",
+ interestingTime,
+ interestingDuration);
+ return _res;
+}
+
+static PyObject *MovieObj_AddMovieResource(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short resRefNum;
+ short resId;
+ Str255 resName;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &resRefNum,
+ PyMac_GetStr255, resName))
+ return NULL;
+ _err = AddMovieResource(_self->ob_itself,
+ resRefNum,
+ &resId,
+ resName);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ resId);
+ return _res;
+}
+
+static PyObject *MovieObj_UpdateMovieResource(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short resRefNum;
+ short resId;
+ Str255 resName;
+ if (!PyArg_ParseTuple(_args, "hhO&",
+ &resRefNum,
+ &resId,
+ PyMac_GetStr255, resName))
+ return NULL;
+ _err = UpdateMovieResource(_self->ob_itself,
+ resRefNum,
+ resId,
+ resName);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_HasMovieChanged(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = HasMovieChanged(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_ClearMovieChanged(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ClearMovieChanged(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_SetMovieDefaultDataRef(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataRef;
+ OSType dataRefType;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
+ return NULL;
+ _err = SetMovieDefaultDataRef(_self->ob_itself,
+ dataRef,
+ dataRefType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieDefaultDataRef(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataRef;
+ OSType dataRefType;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetMovieDefaultDataRef(_self->ob_itself,
+ &dataRef,
+ &dataRefType);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&",
+ ResObj_New, dataRef,
+ PyMac_BuildOSType, dataRefType);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *MovieObj_SetMovieAnchorDataRef(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataRef;
+ OSType dataRefType;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
+ return NULL;
+ _err = SetMovieAnchorDataRef(_self->ob_itself,
+ dataRef,
+ dataRefType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *MovieObj_GetMovieAnchorDataRef(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataRef;
+ OSType dataRefType;
+ long outFlags;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetMovieAnchorDataRef(_self->ob_itself,
+ &dataRef,
+ &dataRefType,
+ &outFlags);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&l",
+ ResObj_New, dataRef,
+ PyMac_BuildOSType, dataRefType,
+ outFlags);
+ return _res;
+}
+#endif
+
+static PyObject *MovieObj_SetMovieColorTable(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ CTabHandle ctab;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &ctab))
+ return NULL;
+ _err = SetMovieColorTable(_self->ob_itself,
+ ctab);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieColorTable(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ CTabHandle ctab;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetMovieColorTable(_self->ob_itself,
+ &ctab);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, ctab);
+ return _res;
+}
+
+static PyObject *MovieObj_FlattenMovie(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long movieFlattenFlags;
+ FSSpec theFile;
+ OSType creator;
+ ScriptCode scriptTag;
+ long createMovieFileFlags;
+ short resId;
+ Str255 resName;
+ if (!PyArg_ParseTuple(_args, "lO&O&hlO&",
+ &movieFlattenFlags,
+ PyMac_GetFSSpec, &theFile,
+ PyMac_GetOSType, &creator,
+ &scriptTag,
+ &createMovieFileFlags,
+ PyMac_GetStr255, resName))
+ return NULL;
+ FlattenMovie(_self->ob_itself,
+ movieFlattenFlags,
+ &theFile,
+ creator,
+ scriptTag,
+ createMovieFileFlags,
+ &resId,
+ resName);
+ _res = Py_BuildValue("h",
+ resId);
+ return _res;
+}
+
+static PyObject *MovieObj_FlattenMovieData(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Movie _rv;
+ long movieFlattenFlags;
+ FSSpec theFile;
+ OSType creator;
+ ScriptCode scriptTag;
+ long createMovieFileFlags;
+ if (!PyArg_ParseTuple(_args, "lO&O&hl",
+ &movieFlattenFlags,
+ PyMac_GetFSSpec, &theFile,
+ PyMac_GetOSType, &creator,
+ &scriptTag,
+ &createMovieFileFlags))
+ return NULL;
+ _rv = FlattenMovieData(_self->ob_itself,
+ movieFlattenFlags,
+ &theFile,
+ creator,
+ scriptTag,
+ createMovieFileFlags);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_MovieSearchText(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Ptr text;
+ long size;
+ long searchFlags;
+ Track searchTrack;
+ TimeValue searchTime;
+ long searchOffset;
+ if (!PyArg_ParseTuple(_args, "sll",
+ &text,
+ &size,
+ &searchFlags))
+ return NULL;
+ _err = MovieSearchText(_self->ob_itself,
+ text,
+ size,
+ searchFlags,
+ &searchTrack,
+ &searchTime,
+ &searchOffset);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&ll",
+ TrackObj_New, searchTrack,
+ searchTime,
+ searchOffset);
+ return _res;
+}
+
+static PyObject *MovieObj_GetPosterBox(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect boxRect;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetPosterBox(_self->ob_itself,
+ &boxRect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &boxRect);
+ return _res;
+}
+
+static PyObject *MovieObj_SetPosterBox(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect boxRect;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &boxRect))
+ return NULL;
+ SetPosterBox(_self->ob_itself,
+ &boxRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieSegmentDisplayBoundsRgn(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ TimeValue time;
+ TimeValue duration;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &time,
+ &duration))
+ return NULL;
+ _rv = GetMovieSegmentDisplayBoundsRgn(_self->ob_itself,
+ time,
+ duration);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_GetMovieStatus(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ Track firstProblemTrack;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieStatus(_self->ob_itself,
+ &firstProblemTrack);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ TrackObj_New, firstProblemTrack);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *MovieObj_GetMovieLoadState(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMovieLoadState(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *MovieObj_NewMovieController(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MovieController _rv;
+ Rect movieRect;
+ long someFlags;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetRect, &movieRect,
+ &someFlags))
+ return NULL;
+ _rv = NewMovieController(_self->ob_itself,
+ &movieRect,
+ someFlags);
+ _res = Py_BuildValue("O&",
+ MovieCtlObj_New, _rv);
+ return _res;
+}
+
+static PyObject *MovieObj_PutMovieOnScrap(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long movieScrapFlags;
+ if (!PyArg_ParseTuple(_args, "l",
+ &movieScrapFlags))
+ return NULL;
+ _err = PutMovieOnScrap(_self->ob_itself,
+ movieScrapFlags);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_SetMoviePlayHints(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long flags;
+ long flagsMask;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &flags,
+ &flagsMask))
+ return NULL;
+ SetMoviePlayHints(_self->ob_itself,
+ flags,
+ flagsMask);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MovieObj_GetMaxLoadedTimeInMovie(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ TimeValue time;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetMaxLoadedTimeInMovie(_self->ob_itself,
+ &time);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ time);
+ return _res;
+}
+
+static PyObject *MovieObj_QTMovieNeedsTimeTable(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Boolean needsTimeTable;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = QTMovieNeedsTimeTable(_self->ob_itself,
+ &needsTimeTable);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("b",
+ needsTimeTable);
+ return _res;
+}
+
+static PyObject *MovieObj_QTGetDataRefMaxFileOffset(MovieObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType dataRefType;
+ Handle dataRef;
+ long offset;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &dataRefType,
+ ResObj_Convert, &dataRef))
+ return NULL;
+ _err = QTGetDataRefMaxFileOffset(_self->ob_itself,
+ dataRefType,
+ dataRef,
+ &offset);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ offset);
+ return _res;
+}
+
+static PyMethodDef MovieObj_methods[] = {
+ {"MoviesTask", (PyCFunction)MovieObj_MoviesTask, 1,
+ "(long maxMilliSecToUse) -> None"},
+ {"PrerollMovie", (PyCFunction)MovieObj_PrerollMovie, 1,
+ "(TimeValue time, Fixed Rate) -> None"},
+ {"AbortPrePrerollMovie", (PyCFunction)MovieObj_AbortPrePrerollMovie, 1,
+ "(OSErr err) -> None"},
+ {"LoadMovieIntoRam", (PyCFunction)MovieObj_LoadMovieIntoRam, 1,
+ "(TimeValue time, TimeValue duration, long flags) -> None"},
+ {"SetMovieActive", (PyCFunction)MovieObj_SetMovieActive, 1,
+ "(Boolean active) -> None"},
+ {"GetMovieActive", (PyCFunction)MovieObj_GetMovieActive, 1,
+ "() -> (Boolean _rv)"},
+ {"StartMovie", (PyCFunction)MovieObj_StartMovie, 1,
+ "() -> None"},
+ {"StopMovie", (PyCFunction)MovieObj_StopMovie, 1,
+ "() -> None"},
+ {"GoToBeginningOfMovie", (PyCFunction)MovieObj_GoToBeginningOfMovie, 1,
+ "() -> None"},
+ {"GoToEndOfMovie", (PyCFunction)MovieObj_GoToEndOfMovie, 1,
+ "() -> None"},
+ {"IsMovieDone", (PyCFunction)MovieObj_IsMovieDone, 1,
+ "() -> (Boolean _rv)"},
+ {"GetMoviePreviewMode", (PyCFunction)MovieObj_GetMoviePreviewMode, 1,
+ "() -> (Boolean _rv)"},
+ {"SetMoviePreviewMode", (PyCFunction)MovieObj_SetMoviePreviewMode, 1,
+ "(Boolean usePreview) -> None"},
+ {"ShowMoviePoster", (PyCFunction)MovieObj_ShowMoviePoster, 1,
+ "() -> None"},
+ {"GetMovieTimeBase", (PyCFunction)MovieObj_GetMovieTimeBase, 1,
+ "() -> (TimeBase _rv)"},
+ {"SetMovieMasterTimeBase", (PyCFunction)MovieObj_SetMovieMasterTimeBase, 1,
+ "(TimeBase tb, TimeRecord slaveZero) -> None"},
+ {"SetMovieMasterClock", (PyCFunction)MovieObj_SetMovieMasterClock, 1,
+ "(Component clockMeister, TimeRecord slaveZero) -> None"},
+ {"GetMovieGWorld", (PyCFunction)MovieObj_GetMovieGWorld, 1,
+ "() -> (CGrafPtr port, GDHandle gdh)"},
+ {"SetMovieGWorld", (PyCFunction)MovieObj_SetMovieGWorld, 1,
+ "(CGrafPtr port, GDHandle gdh) -> None"},
+ {"GetMovieNaturalBoundsRect", (PyCFunction)MovieObj_GetMovieNaturalBoundsRect, 1,
+ "() -> (Rect naturalBounds)"},
+ {"GetNextTrackForCompositing", (PyCFunction)MovieObj_GetNextTrackForCompositing, 1,
+ "(Track theTrack) -> (Track _rv)"},
+ {"GetPrevTrackForCompositing", (PyCFunction)MovieObj_GetPrevTrackForCompositing, 1,
+ "(Track theTrack) -> (Track _rv)"},
+ {"GetMoviePict", (PyCFunction)MovieObj_GetMoviePict, 1,
+ "(TimeValue time) -> (PicHandle _rv)"},
+ {"GetMoviePosterPict", (PyCFunction)MovieObj_GetMoviePosterPict, 1,
+ "() -> (PicHandle _rv)"},
+ {"UpdateMovie", (PyCFunction)MovieObj_UpdateMovie, 1,
+ "() -> None"},
+ {"InvalidateMovieRegion", (PyCFunction)MovieObj_InvalidateMovieRegion, 1,
+ "(RgnHandle invalidRgn) -> None"},
+ {"GetMovieBox", (PyCFunction)MovieObj_GetMovieBox, 1,
+ "() -> (Rect boxRect)"},
+ {"SetMovieBox", (PyCFunction)MovieObj_SetMovieBox, 1,
+ "(Rect boxRect) -> None"},
+ {"GetMovieDisplayClipRgn", (PyCFunction)MovieObj_GetMovieDisplayClipRgn, 1,
+ "() -> (RgnHandle _rv)"},
+ {"SetMovieDisplayClipRgn", (PyCFunction)MovieObj_SetMovieDisplayClipRgn, 1,
+ "(RgnHandle theClip) -> None"},
+ {"GetMovieClipRgn", (PyCFunction)MovieObj_GetMovieClipRgn, 1,
+ "() -> (RgnHandle _rv)"},
+ {"SetMovieClipRgn", (PyCFunction)MovieObj_SetMovieClipRgn, 1,
+ "(RgnHandle theClip) -> None"},
+ {"GetMovieDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieDisplayBoundsRgn, 1,
+ "() -> (RgnHandle _rv)"},
+ {"GetMovieBoundsRgn", (PyCFunction)MovieObj_GetMovieBoundsRgn, 1,
+ "() -> (RgnHandle _rv)"},
+ {"PutMovieIntoHandle", (PyCFunction)MovieObj_PutMovieIntoHandle, 1,
+ "(Handle publicMovie) -> None"},
+ {"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1,
+ "(short fRefNum, long offset, long maxSize) -> None"},
+ {"PutMovieIntoDataFork64", (PyCFunction)MovieObj_PutMovieIntoDataFork64, 1,
+ "(long fRefNum, wide offset, unsigned long maxSize) -> None"},
+ {"GetMovieCreationTime", (PyCFunction)MovieObj_GetMovieCreationTime, 1,
+ "() -> (unsigned long _rv)"},
+ {"GetMovieModificationTime", (PyCFunction)MovieObj_GetMovieModificationTime, 1,
+ "() -> (unsigned long _rv)"},
+ {"GetMovieTimeScale", (PyCFunction)MovieObj_GetMovieTimeScale, 1,
+ "() -> (TimeScale _rv)"},
+ {"SetMovieTimeScale", (PyCFunction)MovieObj_SetMovieTimeScale, 1,
+ "(TimeScale timeScale) -> None"},
+ {"GetMovieDuration", (PyCFunction)MovieObj_GetMovieDuration, 1,
+ "() -> (TimeValue _rv)"},
+ {"GetMovieRate", (PyCFunction)MovieObj_GetMovieRate, 1,
+ "() -> (Fixed _rv)"},
+ {"SetMovieRate", (PyCFunction)MovieObj_SetMovieRate, 1,
+ "(Fixed rate) -> None"},
+ {"GetMoviePreferredRate", (PyCFunction)MovieObj_GetMoviePreferredRate, 1,
+ "() -> (Fixed _rv)"},
+ {"SetMoviePreferredRate", (PyCFunction)MovieObj_SetMoviePreferredRate, 1,
+ "(Fixed rate) -> None"},
+ {"GetMoviePreferredVolume", (PyCFunction)MovieObj_GetMoviePreferredVolume, 1,
+ "() -> (short _rv)"},
+ {"SetMoviePreferredVolume", (PyCFunction)MovieObj_SetMoviePreferredVolume, 1,
+ "(short volume) -> None"},
+ {"GetMovieVolume", (PyCFunction)MovieObj_GetMovieVolume, 1,
+ "() -> (short _rv)"},
+ {"SetMovieVolume", (PyCFunction)MovieObj_SetMovieVolume, 1,
+ "(short volume) -> None"},
+ {"GetMoviePreviewTime", (PyCFunction)MovieObj_GetMoviePreviewTime, 1,
+ "() -> (TimeValue previewTime, TimeValue previewDuration)"},
+ {"SetMoviePreviewTime", (PyCFunction)MovieObj_SetMoviePreviewTime, 1,
+ "(TimeValue previewTime, TimeValue previewDuration) -> None"},
+ {"GetMoviePosterTime", (PyCFunction)MovieObj_GetMoviePosterTime, 1,
+ "() -> (TimeValue _rv)"},
+ {"SetMoviePosterTime", (PyCFunction)MovieObj_SetMoviePosterTime, 1,
+ "(TimeValue posterTime) -> None"},
+ {"GetMovieSelection", (PyCFunction)MovieObj_GetMovieSelection, 1,
+ "() -> (TimeValue selectionTime, TimeValue selectionDuration)"},
+ {"SetMovieSelection", (PyCFunction)MovieObj_SetMovieSelection, 1,
+ "(TimeValue selectionTime, TimeValue selectionDuration) -> None"},
+ {"SetMovieActiveSegment", (PyCFunction)MovieObj_SetMovieActiveSegment, 1,
+ "(TimeValue startTime, TimeValue duration) -> None"},
+ {"GetMovieActiveSegment", (PyCFunction)MovieObj_GetMovieActiveSegment, 1,
+ "() -> (TimeValue startTime, TimeValue duration)"},
+ {"GetMovieTime", (PyCFunction)MovieObj_GetMovieTime, 1,
+ "() -> (TimeValue _rv, TimeRecord currentTime)"},
+ {"SetMovieTime", (PyCFunction)MovieObj_SetMovieTime, 1,
+ "(TimeRecord newtime) -> None"},
+ {"SetMovieTimeValue", (PyCFunction)MovieObj_SetMovieTimeValue, 1,
+ "(TimeValue newtime) -> None"},
+ {"GetMovieUserData", (PyCFunction)MovieObj_GetMovieUserData, 1,
+ "() -> (UserData _rv)"},
+ {"GetMovieTrackCount", (PyCFunction)MovieObj_GetMovieTrackCount, 1,
+ "() -> (long _rv)"},
+ {"GetMovieTrack", (PyCFunction)MovieObj_GetMovieTrack, 1,
+ "(long trackID) -> (Track _rv)"},
+ {"GetMovieIndTrack", (PyCFunction)MovieObj_GetMovieIndTrack, 1,
+ "(long index) -> (Track _rv)"},
+ {"GetMovieIndTrackType", (PyCFunction)MovieObj_GetMovieIndTrackType, 1,
+ "(long index, OSType trackType, long flags) -> (Track _rv)"},
+ {"NewMovieTrack", (PyCFunction)MovieObj_NewMovieTrack, 1,
+ "(Fixed width, Fixed height, short trackVolume) -> (Track _rv)"},
+ {"SetAutoTrackAlternatesEnabled", (PyCFunction)MovieObj_SetAutoTrackAlternatesEnabled, 1,
+ "(Boolean enable) -> None"},
+ {"SelectMovieAlternates", (PyCFunction)MovieObj_SelectMovieAlternates, 1,
+ "() -> None"},
+ {"InsertMovieSegment", (PyCFunction)MovieObj_InsertMovieSegment, 1,
+ "(Movie dstMovie, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None"},
+ {"InsertEmptyMovieSegment", (PyCFunction)MovieObj_InsertEmptyMovieSegment, 1,
+ "(TimeValue dstIn, TimeValue dstDuration) -> None"},
+ {"DeleteMovieSegment", (PyCFunction)MovieObj_DeleteMovieSegment, 1,
+ "(TimeValue startTime, TimeValue duration) -> None"},
+ {"ScaleMovieSegment", (PyCFunction)MovieObj_ScaleMovieSegment, 1,
+ "(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None"},
+ {"CutMovieSelection", (PyCFunction)MovieObj_CutMovieSelection, 1,
+ "() -> (Movie _rv)"},
+ {"CopyMovieSelection", (PyCFunction)MovieObj_CopyMovieSelection, 1,
+ "() -> (Movie _rv)"},
+ {"PasteMovieSelection", (PyCFunction)MovieObj_PasteMovieSelection, 1,
+ "(Movie src) -> None"},
+ {"AddMovieSelection", (PyCFunction)MovieObj_AddMovieSelection, 1,
+ "(Movie src) -> None"},
+ {"ClearMovieSelection", (PyCFunction)MovieObj_ClearMovieSelection, 1,
+ "() -> None"},
+ {"PutMovieIntoTypedHandle", (PyCFunction)MovieObj_PutMovieIntoTypedHandle, 1,
+ "(Track targetTrack, OSType handleType, Handle publicMovie, TimeValue start, TimeValue dur, long flags, ComponentInstance userComp) -> None"},
+ {"CopyMovieSettings", (PyCFunction)MovieObj_CopyMovieSettings, 1,
+ "(Movie dstMovie) -> None"},
+ {"ConvertMovieToFile", (PyCFunction)MovieObj_ConvertMovieToFile, 1,
+ "(Track onlyTrack, FSSpec outputFile, OSType fileType, OSType creator, ScriptCode scriptTag, long flags, ComponentInstance userComp) -> (short resID)"},
+ {"GetMovieDataSize", (PyCFunction)MovieObj_GetMovieDataSize, 1,
+ "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
+ {"GetMovieDataSize64", (PyCFunction)MovieObj_GetMovieDataSize64, 1,
+ "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
+ {"PtInMovie", (PyCFunction)MovieObj_PtInMovie, 1,
+ "(Point pt) -> (Boolean _rv)"},
+ {"SetMovieLanguage", (PyCFunction)MovieObj_SetMovieLanguage, 1,
+ "(long language) -> None"},
+ {"GetMovieNextInterestingTime", (PyCFunction)MovieObj_GetMovieNextInterestingTime, 1,
+ "(short interestingTimeFlags, short numMediaTypes, OSType whichMediaTypes, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
+ {"AddMovieResource", (PyCFunction)MovieObj_AddMovieResource, 1,
+ "(short resRefNum, Str255 resName) -> (short resId)"},
+ {"UpdateMovieResource", (PyCFunction)MovieObj_UpdateMovieResource, 1,
+ "(short resRefNum, short resId, Str255 resName) -> None"},
+ {"HasMovieChanged", (PyCFunction)MovieObj_HasMovieChanged, 1,
+ "() -> (Boolean _rv)"},
+ {"ClearMovieChanged", (PyCFunction)MovieObj_ClearMovieChanged, 1,
+ "() -> None"},
+ {"SetMovieDefaultDataRef", (PyCFunction)MovieObj_SetMovieDefaultDataRef, 1,
+ "(Handle dataRef, OSType dataRefType) -> None"},
+ {"GetMovieDefaultDataRef", (PyCFunction)MovieObj_GetMovieDefaultDataRef, 1,
+ "() -> (Handle dataRef, OSType dataRefType)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"SetMovieAnchorDataRef", (PyCFunction)MovieObj_SetMovieAnchorDataRef, 1,
+ "(Handle dataRef, OSType dataRefType) -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"GetMovieAnchorDataRef", (PyCFunction)MovieObj_GetMovieAnchorDataRef, 1,
+ "() -> (Handle dataRef, OSType dataRefType, long outFlags)"},
+#endif
+ {"SetMovieColorTable", (PyCFunction)MovieObj_SetMovieColorTable, 1,
+ "(CTabHandle ctab) -> None"},
+ {"GetMovieColorTable", (PyCFunction)MovieObj_GetMovieColorTable, 1,
+ "() -> (CTabHandle ctab)"},
+ {"FlattenMovie", (PyCFunction)MovieObj_FlattenMovie, 1,
+ "(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Str255 resName) -> (short resId)"},
+ {"FlattenMovieData", (PyCFunction)MovieObj_FlattenMovieData, 1,
+ "(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)"},
+ {"MovieSearchText", (PyCFunction)MovieObj_MovieSearchText, 1,
+ "(Ptr text, long size, long searchFlags) -> (Track searchTrack, TimeValue searchTime, long searchOffset)"},
+ {"GetPosterBox", (PyCFunction)MovieObj_GetPosterBox, 1,
+ "() -> (Rect boxRect)"},
+ {"SetPosterBox", (PyCFunction)MovieObj_SetPosterBox, 1,
+ "(Rect boxRect) -> None"},
+ {"GetMovieSegmentDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieSegmentDisplayBoundsRgn, 1,
+ "(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"},
+ {"GetMovieStatus", (PyCFunction)MovieObj_GetMovieStatus, 1,
+ "() -> (ComponentResult _rv, Track firstProblemTrack)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"GetMovieLoadState", (PyCFunction)MovieObj_GetMovieLoadState, 1,
+ "() -> (long _rv)"},
+#endif
+ {"NewMovieController", (PyCFunction)MovieObj_NewMovieController, 1,
+ "(Rect movieRect, long someFlags) -> (MovieController _rv)"},
+ {"PutMovieOnScrap", (PyCFunction)MovieObj_PutMovieOnScrap, 1,
+ "(long movieScrapFlags) -> None"},
+ {"SetMoviePlayHints", (PyCFunction)MovieObj_SetMoviePlayHints, 1,
+ "(long flags, long flagsMask) -> None"},
+ {"GetMaxLoadedTimeInMovie", (PyCFunction)MovieObj_GetMaxLoadedTimeInMovie, 1,
+ "() -> (TimeValue time)"},
+ {"QTMovieNeedsTimeTable", (PyCFunction)MovieObj_QTMovieNeedsTimeTable, 1,
+ "() -> (Boolean needsTimeTable)"},
+ {"QTGetDataRefMaxFileOffset", (PyCFunction)MovieObj_QTGetDataRefMaxFileOffset, 1,
+ "(OSType dataRefType, Handle dataRef) -> (long offset)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain MovieObj_chain = { MovieObj_methods, NULL };
+
+static PyObject *MovieObj_getattr(MovieObject *self, char *name)
+{
+ return Py_FindMethodInChain(&MovieObj_chain, (PyObject *)self, name);
+}
+
+#define MovieObj_setattr NULL
+
+#define MovieObj_compare NULL
+
+#define MovieObj_repr NULL
+
+#define MovieObj_hash NULL
+
+PyTypeObject Movie_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "Movie", /*tp_name*/
+ sizeof(MovieObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) MovieObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) MovieObj_getattr, /*tp_getattr*/
+ (setattrfunc) MovieObj_setattr, /*tp_setattr*/
+ (cmpfunc) MovieObj_compare, /*tp_compare*/
+ (reprfunc) MovieObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) MovieObj_hash, /*tp_hash*/
+};
+
+/* --------------------- End object type Movie ---------------------- */
+
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Qt_CheckQuickTimeRegistration(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ void * registrationKey;
+ long flags;
+ if (!PyArg_ParseTuple(_args, "sl",
+ ®istrationKey,
+ &flags))
+ return NULL;
+ CheckQuickTimeRegistration(registrationKey,
+ flags);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Qt_EnterMovies(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = EnterMovies();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_ExitMovies(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ExitMovies();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_GetMoviesError(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetMoviesError();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_ClearMoviesStickyError(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ClearMoviesStickyError();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_GetMoviesStickyError(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetMoviesStickyError();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_DisposeMatte(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixMapHandle theMatte;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theMatte))
+ return NULL;
+ DisposeMatte(theMatte);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_NewMovie(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Movie _rv;
+ long flags;
+ if (!PyArg_ParseTuple(_args, "l",
+ &flags))
+ return NULL;
+ _rv = NewMovie(flags);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qt_GetDataHandler(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Component _rv;
+ Handle dataRef;
+ OSType dataHandlerSubType;
+ long flags;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataHandlerSubType,
+ &flags))
+ return NULL;
+ _rv = GetDataHandler(dataRef,
+ dataHandlerSubType,
+ flags);
+ _res = Py_BuildValue("O&",
+ CmpObj_New, _rv);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Qt_OpenADataHandler(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle dataRef;
+ OSType dataHandlerSubType;
+ Handle anchorDataRef;
+ OSType anchorDataRefType;
+ TimeBase tb;
+ long flags;
+ ComponentInstance dh;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&O&l",
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataHandlerSubType,
+ ResObj_Convert, &anchorDataRef,
+ PyMac_GetOSType, &anchorDataRefType,
+ TimeBaseObj_Convert, &tb,
+ &flags))
+ return NULL;
+ _err = OpenADataHandler(dataRef,
+ dataHandlerSubType,
+ anchorDataRef,
+ anchorDataRefType,
+ tb,
+ flags,
+ &dh);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CmpInstObj_New, dh);
+ return _res;
+}
+#endif
+
+static PyObject *Qt_PasteHandleIntoMovie(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle h;
+ OSType handleType;
+ Movie theMovie;
+ long flags;
+ ComponentInstance userComp;
+ if (!PyArg_ParseTuple(_args, "O&O&O&lO&",
+ ResObj_Convert, &h,
+ PyMac_GetOSType, &handleType,
+ MovieObj_Convert, &theMovie,
+ &flags,
+ CmpInstObj_Convert, &userComp))
+ return NULL;
+ _err = PasteHandleIntoMovie(h,
+ handleType,
+ theMovie,
+ flags,
+ userComp);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_GetMovieImporterForDataRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType dataRefType;
+ Handle dataRef;
+ long flags;
+ Component importer;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ PyMac_GetOSType, &dataRefType,
+ ResObj_Convert, &dataRef,
+ &flags))
+ return NULL;
+ _err = GetMovieImporterForDataRef(dataRefType,
+ dataRef,
+ flags,
+ &importer);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CmpObj_New, importer);
+ return _res;
+}
+
+static PyObject *Qt_TrackTimeToMediaTime(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeValue _rv;
+ TimeValue value;
+ Track theTrack;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &value,
+ TrackObj_Convert, &theTrack))
+ return NULL;
+ _rv = TrackTimeToMediaTime(value,
+ theTrack);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_NewUserData(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ UserData theUserData;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = NewUserData(&theUserData);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ UserDataObj_New, theUserData);
+ return _res;
+}
+
+static PyObject *Qt_NewUserDataFromHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle h;
+ UserData theUserData;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &h))
+ return NULL;
+ _err = NewUserDataFromHandle(h,
+ &theUserData);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ UserDataObj_New, theUserData);
+ return _res;
+}
+
+static PyObject *Qt_CreateMovieFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ FSSpec fileSpec;
+ OSType creator;
+ ScriptCode scriptTag;
+ long createMovieFileFlags;
+ short resRefNum;
+ Movie newmovie;
+ if (!PyArg_ParseTuple(_args, "O&O&hl",
+ PyMac_GetFSSpec, &fileSpec,
+ PyMac_GetOSType, &creator,
+ &scriptTag,
+ &createMovieFileFlags))
+ return NULL;
+ _err = CreateMovieFile(&fileSpec,
+ creator,
+ scriptTag,
+ createMovieFileFlags,
+ &resRefNum,
+ &newmovie);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("hO&",
+ resRefNum,
+ MovieObj_New, newmovie);
+ return _res;
+}
+
+static PyObject *Qt_OpenMovieFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ FSSpec fileSpec;
+ short resRefNum;
+ SInt8 permission;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ PyMac_GetFSSpec, &fileSpec,
+ &permission))
+ return NULL;
+ _err = OpenMovieFile(&fileSpec,
+ &resRefNum,
+ permission);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ resRefNum);
+ return _res;
+}
+
+static PyObject *Qt_CloseMovieFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short resRefNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &resRefNum))
+ return NULL;
+ _err = CloseMovieFile(resRefNum);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_DeleteMovieFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ FSSpec fileSpec;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFSSpec, &fileSpec))
+ return NULL;
+ _err = DeleteMovieFile(&fileSpec);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_NewMovieFromFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Movie theMovie;
+ short resRefNum;
+ short resId;
+ short newMovieFlags;
+ Boolean dataRefWasChanged;
+ if (!PyArg_ParseTuple(_args, "hhh",
+ &resRefNum,
+ &resId,
+ &newMovieFlags))
+ return NULL;
+ _err = NewMovieFromFile(&theMovie,
+ resRefNum,
+ &resId,
+ (StringPtr)0,
+ newMovieFlags,
+ &dataRefWasChanged);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&hb",
+ MovieObj_New, theMovie,
+ resId,
+ dataRefWasChanged);
+ return _res;
+}
+
+static PyObject *Qt_NewMovieFromHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Movie theMovie;
+ Handle h;
+ short newMovieFlags;
+ Boolean dataRefWasChanged;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ ResObj_Convert, &h,
+ &newMovieFlags))
+ return NULL;
+ _err = NewMovieFromHandle(&theMovie,
+ h,
+ newMovieFlags,
+ &dataRefWasChanged);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&b",
+ MovieObj_New, theMovie,
+ dataRefWasChanged);
+ return _res;
+}
+
+static PyObject *Qt_NewMovieFromDataFork(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Movie theMovie;
+ short fRefNum;
+ long fileOffset;
+ short newMovieFlags;
+ Boolean dataRefWasChanged;
+ if (!PyArg_ParseTuple(_args, "hlh",
+ &fRefNum,
+ &fileOffset,
+ &newMovieFlags))
+ return NULL;
+ _err = NewMovieFromDataFork(&theMovie,
+ fRefNum,
+ fileOffset,
+ newMovieFlags,
+ &dataRefWasChanged);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&b",
+ MovieObj_New, theMovie,
+ dataRefWasChanged);
+ return _res;
+}
+
+static PyObject *Qt_NewMovieFromDataFork64(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Movie theMovie;
+ long fRefNum;
+ wide fileOffset;
+ short newMovieFlags;
+ Boolean dataRefWasChanged;
+ if (!PyArg_ParseTuple(_args, "lO&h",
+ &fRefNum,
+ PyMac_Getwide, &fileOffset,
+ &newMovieFlags))
+ return NULL;
+ _err = NewMovieFromDataFork64(&theMovie,
+ fRefNum,
+ &fileOffset,
+ newMovieFlags,
+ &dataRefWasChanged);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&b",
+ MovieObj_New, theMovie,
+ dataRefWasChanged);
+ return _res;
+}
+
+static PyObject *Qt_NewMovieFromDataRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Movie m;
+ short flags;
+ short id;
+ Handle dataRef;
+ OSType dataRefType;
+ if (!PyArg_ParseTuple(_args, "hO&O&",
+ &flags,
+ ResObj_Convert, &dataRef,
+ PyMac_GetOSType, &dataRefType))
+ return NULL;
+ _err = NewMovieFromDataRef(&m,
+ flags,
+ &id,
+ dataRef,
+ dataRefType);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&h",
+ MovieObj_New, m,
+ id);
+ return _res;
+}
+
+static PyObject *Qt_RemoveMovieResource(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short resRefNum;
+ short resId;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &resRefNum,
+ &resId))
+ return NULL;
+ _err = RemoveMovieResource(resRefNum,
+ resId);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_CreateShortcutMovieFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ FSSpec fileSpec;
+ OSType creator;
+ ScriptCode scriptTag;
+ long createMovieFileFlags;
+ Handle targetDataRef;
+ OSType targetDataRefType;
+ if (!PyArg_ParseTuple(_args, "O&O&hlO&O&",
+ PyMac_GetFSSpec, &fileSpec,
+ PyMac_GetOSType, &creator,
+ &scriptTag,
+ &createMovieFileFlags,
+ ResObj_Convert, &targetDataRef,
+ PyMac_GetOSType, &targetDataRefType))
+ return NULL;
+ _err = CreateShortcutMovieFile(&fileSpec,
+ creator,
+ scriptTag,
+ createMovieFileFlags,
+ targetDataRef,
+ targetDataRefType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_NewMovieFromScrap(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Movie _rv;
+ long newMovieFlags;
+ if (!PyArg_ParseTuple(_args, "l",
+ &newMovieFlags))
+ return NULL;
+ _rv = NewMovieFromScrap(newMovieFlags);
+ _res = Py_BuildValue("O&",
+ MovieObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qt_QTNewAlias(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ FSSpec fss;
+ AliasHandle alias;
+ Boolean minimal;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ PyMac_GetFSSpec, &fss,
+ &minimal))
+ return NULL;
+ _err = QTNewAlias(&fss,
+ &alias,
+ minimal);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, alias);
+ return _res;
+}
+
+static PyObject *Qt_EndFullScreen(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Ptr fullState;
+ long flags;
+ if (!PyArg_ParseTuple(_args, "sl",
+ &fullState,
+ &flags))
+ return NULL;
+ _err = EndFullScreen(fullState,
+ flags);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_AddSoundDescriptionExtension(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SoundDescriptionHandle desc;
+ Handle extension;
+ OSType idType;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ ResObj_Convert, &desc,
+ ResObj_Convert, &extension,
+ PyMac_GetOSType, &idType))
+ return NULL;
+ _err = AddSoundDescriptionExtension(desc,
+ extension,
+ idType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_GetSoundDescriptionExtension(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SoundDescriptionHandle desc;
+ Handle extension;
+ OSType idType;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &desc,
+ PyMac_GetOSType, &idType))
+ return NULL;
+ _err = GetSoundDescriptionExtension(desc,
+ &extension,
+ idType);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, extension);
+ return _res;
+}
+
+static PyObject *Qt_RemoveSoundDescriptionExtension(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SoundDescriptionHandle desc;
+ OSType idType;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &desc,
+ PyMac_GetOSType, &idType))
+ return NULL;
+ _err = RemoveSoundDescriptionExtension(desc,
+ idType);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_QTIsStandardParameterDialogEvent(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ EventRecord pEvent;
+ QTParameterDialog createdDialog;
+ if (!PyArg_ParseTuple(_args, "l",
+ &createdDialog))
+ return NULL;
+ _err = QTIsStandardParameterDialogEvent(&pEvent,
+ createdDialog);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildEventRecord, &pEvent);
+ return _res;
+}
+
+static PyObject *Qt_QTDismissStandardParameterDialog(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ QTParameterDialog createdDialog;
+ if (!PyArg_ParseTuple(_args, "l",
+ &createdDialog))
+ return NULL;
+ _err = QTDismissStandardParameterDialog(createdDialog);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_QTStandardParameterDialogDoAction(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ QTParameterDialog createdDialog;
+ long action;
+ void * params;
+ if (!PyArg_ParseTuple(_args, "lls",
+ &createdDialog,
+ &action,
+ ¶ms))
+ return NULL;
+ _err = QTStandardParameterDialogDoAction(createdDialog,
+ action,
+ params);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_QTRegisterAccessKey(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Str255 accessKeyType;
+ long flags;
+ Handle accessKey;
+ if (!PyArg_ParseTuple(_args, "O&lO&",
+ PyMac_GetStr255, accessKeyType,
+ &flags,
+ ResObj_Convert, &accessKey))
+ return NULL;
+ _err = QTRegisterAccessKey(accessKeyType,
+ flags,
+ accessKey);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_QTUnregisterAccessKey(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Str255 accessKeyType;
+ long flags;
+ Handle accessKey;
+ if (!PyArg_ParseTuple(_args, "O&lO&",
+ PyMac_GetStr255, accessKeyType,
+ &flags,
+ ResObj_Convert, &accessKey))
+ return NULL;
+ _err = QTUnregisterAccessKey(accessKeyType,
+ flags,
+ accessKey);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_QTTextToNativeText(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle theText;
+ long encoding;
+ long flags;
+ if (!PyArg_ParseTuple(_args, "O&ll",
+ ResObj_Convert, &theText,
+ &encoding,
+ &flags))
+ return NULL;
+ _err = QTTextToNativeText(theText,
+ encoding,
+ flags);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_VideoMediaResetStatistics(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mh))
+ return NULL;
+ _rv = VideoMediaResetStatistics(mh);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_VideoMediaGetStatistics(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mh))
+ return NULL;
+ _rv = VideoMediaGetStatistics(mh);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_VideoMediaGetStallCount(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ unsigned long stalls;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mh))
+ return NULL;
+ _rv = VideoMediaGetStallCount(mh,
+ &stalls);
+ _res = Py_BuildValue("ll",
+ _rv,
+ stalls);
+ return _res;
+}
+
+static PyObject *Qt_VideoMediaSetCodecParameter(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ CodecType cType;
+ OSType parameterID;
+ long parameterChangeSeed;
+ void * dataPtr;
+ long dataSize;
+ if (!PyArg_ParseTuple(_args, "O&O&O&lsl",
+ CmpInstObj_Convert, &mh,
+ PyMac_GetOSType, &cType,
+ PyMac_GetOSType, ¶meterID,
+ ¶meterChangeSeed,
+ &dataPtr,
+ &dataSize))
+ return NULL;
+ _rv = VideoMediaSetCodecParameter(mh,
+ cType,
+ parameterID,
+ parameterChangeSeed,
+ dataPtr,
+ dataSize);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_VideoMediaGetCodecParameter(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ CodecType cType;
+ OSType parameterID;
+ Handle outParameterData;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+ CmpInstObj_Convert, &mh,
+ PyMac_GetOSType, &cType,
+ PyMac_GetOSType, ¶meterID,
+ ResObj_Convert, &outParameterData))
+ return NULL;
+ _rv = VideoMediaGetCodecParameter(mh,
+ cType,
+ parameterID,
+ outParameterData);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TextMediaAddTextSample(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ Ptr text;
+ unsigned long size;
+ short fontNumber;
+ short fontSize;
+ Style textFace;
+ RGBColor textColor;
+ RGBColor backColor;
+ short textJustification;
+ Rect textBox;
+ long displayFlags;
+ TimeValue scrollDelay;
+ short hiliteStart;
+ short hiliteEnd;
+ RGBColor rgbHiliteColor;
+ TimeValue duration;
+ TimeValue sampleTime;
+ if (!PyArg_ParseTuple(_args, "O&slhhbhllhhl",
+ CmpInstObj_Convert, &mh,
+ &text,
+ &size,
+ &fontNumber,
+ &fontSize,
+ &textFace,
+ &textJustification,
+ &displayFlags,
+ &scrollDelay,
+ &hiliteStart,
+ &hiliteEnd,
+ &duration))
+ return NULL;
+ _rv = TextMediaAddTextSample(mh,
+ text,
+ size,
+ fontNumber,
+ fontSize,
+ textFace,
+ &textColor,
+ &backColor,
+ textJustification,
+ &textBox,
+ displayFlags,
+ scrollDelay,
+ hiliteStart,
+ hiliteEnd,
+ &rgbHiliteColor,
+ duration,
+ &sampleTime);
+ _res = Py_BuildValue("lO&O&O&O&l",
+ _rv,
+ QdRGB_New, &textColor,
+ QdRGB_New, &backColor,
+ PyMac_BuildRect, &textBox,
+ QdRGB_New, &rgbHiliteColor,
+ sampleTime);
+ return _res;
+}
+
+static PyObject *Qt_TextMediaAddTESample(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ TEHandle hTE;
+ RGBColor backColor;
+ short textJustification;
+ Rect textBox;
+ long displayFlags;
+ TimeValue scrollDelay;
+ short hiliteStart;
+ short hiliteEnd;
+ RGBColor rgbHiliteColor;
+ TimeValue duration;
+ TimeValue sampleTime;
+ if (!PyArg_ParseTuple(_args, "O&O&hllhhl",
+ CmpInstObj_Convert, &mh,
+ ResObj_Convert, &hTE,
+ &textJustification,
+ &displayFlags,
+ &scrollDelay,
+ &hiliteStart,
+ &hiliteEnd,
+ &duration))
+ return NULL;
+ _rv = TextMediaAddTESample(mh,
+ hTE,
+ &backColor,
+ textJustification,
+ &textBox,
+ displayFlags,
+ scrollDelay,
+ hiliteStart,
+ hiliteEnd,
+ &rgbHiliteColor,
+ duration,
+ &sampleTime);
+ _res = Py_BuildValue("lO&O&O&l",
+ _rv,
+ QdRGB_New, &backColor,
+ PyMac_BuildRect, &textBox,
+ QdRGB_New, &rgbHiliteColor,
+ sampleTime);
+ return _res;
+}
+
+static PyObject *Qt_TextMediaAddHiliteSample(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short hiliteStart;
+ short hiliteEnd;
+ RGBColor rgbHiliteColor;
+ TimeValue duration;
+ TimeValue sampleTime;
+ if (!PyArg_ParseTuple(_args, "O&hhl",
+ CmpInstObj_Convert, &mh,
+ &hiliteStart,
+ &hiliteEnd,
+ &duration))
+ return NULL;
+ _rv = TextMediaAddHiliteSample(mh,
+ hiliteStart,
+ hiliteEnd,
+ &rgbHiliteColor,
+ duration,
+ &sampleTime);
+ _res = Py_BuildValue("lO&l",
+ _rv,
+ QdRGB_New, &rgbHiliteColor,
+ sampleTime);
+ return _res;
+}
+
+static PyObject *Qt_TextMediaDrawRaw(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ GWorldPtr gw;
+ GDHandle gd;
+ void * data;
+ long dataSize;
+ TextDescriptionHandle tdh;
+ if (!PyArg_ParseTuple(_args, "O&O&O&slO&",
+ CmpInstObj_Convert, &mh,
+ GWorldObj_Convert, &gw,
+ OptResObj_Convert, &gd,
+ &data,
+ &dataSize,
+ ResObj_Convert, &tdh))
+ return NULL;
+ _rv = TextMediaDrawRaw(mh,
+ gw,
+ gd,
+ data,
+ dataSize,
+ tdh);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TextMediaSetTextProperty(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ TimeValue atMediaTime;
+ long propertyType;
+ void * data;
+ long dataSize;
+ if (!PyArg_ParseTuple(_args, "O&llsl",
+ CmpInstObj_Convert, &mh,
+ &atMediaTime,
+ &propertyType,
+ &data,
+ &dataSize))
+ return NULL;
+ _rv = TextMediaSetTextProperty(mh,
+ atMediaTime,
+ propertyType,
+ data,
+ dataSize);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TextMediaRawSetup(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ GWorldPtr gw;
+ GDHandle gd;
+ void * data;
+ long dataSize;
+ TextDescriptionHandle tdh;
+ TimeValue sampleDuration;
+ if (!PyArg_ParseTuple(_args, "O&O&O&slO&l",
+ CmpInstObj_Convert, &mh,
+ GWorldObj_Convert, &gw,
+ OptResObj_Convert, &gd,
+ &data,
+ &dataSize,
+ ResObj_Convert, &tdh,
+ &sampleDuration))
+ return NULL;
+ _rv = TextMediaRawSetup(mh,
+ gw,
+ gd,
+ data,
+ dataSize,
+ tdh,
+ sampleDuration);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TextMediaRawIdle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ GWorldPtr gw;
+ GDHandle gd;
+ TimeValue sampleTime;
+ long flagsIn;
+ long flagsOut;
+ if (!PyArg_ParseTuple(_args, "O&O&O&ll",
+ CmpInstObj_Convert, &mh,
+ GWorldObj_Convert, &gw,
+ OptResObj_Convert, &gd,
+ &sampleTime,
+ &flagsIn))
+ return NULL;
+ _rv = TextMediaRawIdle(mh,
+ gw,
+ gd,
+ sampleTime,
+ flagsIn,
+ &flagsOut);
+ _res = Py_BuildValue("ll",
+ _rv,
+ flagsOut);
+ return _res;
+}
+
+static PyObject *Qt_TextMediaFindNextText(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ Ptr text;
+ long size;
+ short findFlags;
+ TimeValue startTime;
+ TimeValue foundTime;
+ TimeValue foundDuration;
+ long offset;
+ if (!PyArg_ParseTuple(_args, "O&slhl",
+ CmpInstObj_Convert, &mh,
+ &text,
+ &size,
+ &findFlags,
+ &startTime))
+ return NULL;
+ _rv = TextMediaFindNextText(mh,
+ text,
+ size,
+ findFlags,
+ startTime,
+ &foundTime,
+ &foundDuration,
+ &offset);
+ _res = Py_BuildValue("llll",
+ _rv,
+ foundTime,
+ foundDuration,
+ offset);
+ return _res;
+}
+
+static PyObject *Qt_TextMediaHiliteTextSample(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ TimeValue sampleTime;
+ short hiliteStart;
+ short hiliteEnd;
+ RGBColor rgbHiliteColor;
+ if (!PyArg_ParseTuple(_args, "O&lhh",
+ CmpInstObj_Convert, &mh,
+ &sampleTime,
+ &hiliteStart,
+ &hiliteEnd))
+ return NULL;
+ _rv = TextMediaHiliteTextSample(mh,
+ sampleTime,
+ hiliteStart,
+ hiliteEnd,
+ &rgbHiliteColor);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ QdRGB_New, &rgbHiliteColor);
+ return _res;
+}
+
+static PyObject *Qt_TextMediaSetTextSampleData(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ void * data;
+ OSType dataType;
+ if (!PyArg_ParseTuple(_args, "O&sO&",
+ CmpInstObj_Convert, &mh,
+ &data,
+ PyMac_GetOSType, &dataType))
+ return NULL;
+ _rv = TextMediaSetTextSampleData(mh,
+ data,
+ dataType);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaSetProperty(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short spriteIndex;
+ long propertyType;
+ void * propertyValue;
+ if (!PyArg_ParseTuple(_args, "O&hls",
+ CmpInstObj_Convert, &mh,
+ &spriteIndex,
+ &propertyType,
+ &propertyValue))
+ return NULL;
+ _rv = SpriteMediaSetProperty(mh,
+ spriteIndex,
+ propertyType,
+ propertyValue);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaGetProperty(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short spriteIndex;
+ long propertyType;
+ void * propertyValue;
+ if (!PyArg_ParseTuple(_args, "O&hls",
+ CmpInstObj_Convert, &mh,
+ &spriteIndex,
+ &propertyType,
+ &propertyValue))
+ return NULL;
+ _rv = SpriteMediaGetProperty(mh,
+ spriteIndex,
+ propertyType,
+ propertyValue);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaHitTestSprites(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long flags;
+ Point loc;
+ short spriteHitIndex;
+ if (!PyArg_ParseTuple(_args, "O&lO&",
+ CmpInstObj_Convert, &mh,
+ &flags,
+ PyMac_GetPoint, &loc))
+ return NULL;
+ _rv = SpriteMediaHitTestSprites(mh,
+ flags,
+ loc,
+ &spriteHitIndex);
+ _res = Py_BuildValue("lh",
+ _rv,
+ spriteHitIndex);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaCountSprites(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short numSprites;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mh))
+ return NULL;
+ _rv = SpriteMediaCountSprites(mh,
+ &numSprites);
+ _res = Py_BuildValue("lh",
+ _rv,
+ numSprites);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaCountImages(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short numImages;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mh))
+ return NULL;
+ _rv = SpriteMediaCountImages(mh,
+ &numImages);
+ _res = Py_BuildValue("lh",
+ _rv,
+ numImages);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaGetIndImageDescription(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short imageIndex;
+ ImageDescriptionHandle imageDescription;
+ if (!PyArg_ParseTuple(_args, "O&hO&",
+ CmpInstObj_Convert, &mh,
+ &imageIndex,
+ ResObj_Convert, &imageDescription))
+ return NULL;
+ _rv = SpriteMediaGetIndImageDescription(mh,
+ imageIndex,
+ imageDescription);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaGetDisplayedSampleNumber(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long sampleNum;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mh))
+ return NULL;
+ _rv = SpriteMediaGetDisplayedSampleNumber(mh,
+ &sampleNum);
+ _res = Py_BuildValue("ll",
+ _rv,
+ sampleNum);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaGetSpriteName(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID spriteID;
+ Str255 spriteName;
+ if (!PyArg_ParseTuple(_args, "O&lO&",
+ CmpInstObj_Convert, &mh,
+ &spriteID,
+ PyMac_GetStr255, spriteName))
+ return NULL;
+ _rv = SpriteMediaGetSpriteName(mh,
+ spriteID,
+ spriteName);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaGetImageName(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short imageIndex;
+ Str255 imageName;
+ if (!PyArg_ParseTuple(_args, "O&hO&",
+ CmpInstObj_Convert, &mh,
+ &imageIndex,
+ PyMac_GetStr255, imageName))
+ return NULL;
+ _rv = SpriteMediaGetImageName(mh,
+ imageIndex,
+ imageName);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaSetSpriteProperty(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID spriteID;
+ long propertyType;
+ void * propertyValue;
+ if (!PyArg_ParseTuple(_args, "O&lls",
+ CmpInstObj_Convert, &mh,
+ &spriteID,
+ &propertyType,
+ &propertyValue))
+ return NULL;
+ _rv = SpriteMediaSetSpriteProperty(mh,
+ spriteID,
+ propertyType,
+ propertyValue);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaGetSpriteProperty(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID spriteID;
+ long propertyType;
+ void * propertyValue;
+ if (!PyArg_ParseTuple(_args, "O&lls",
+ CmpInstObj_Convert, &mh,
+ &spriteID,
+ &propertyType,
+ &propertyValue))
+ return NULL;
+ _rv = SpriteMediaGetSpriteProperty(mh,
+ spriteID,
+ propertyType,
+ propertyValue);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaHitTestAllSprites(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long flags;
+ Point loc;
+ QTAtomID spriteHitID;
+ if (!PyArg_ParseTuple(_args, "O&lO&",
+ CmpInstObj_Convert, &mh,
+ &flags,
+ PyMac_GetPoint, &loc))
+ return NULL;
+ _rv = SpriteMediaHitTestAllSprites(mh,
+ flags,
+ loc,
+ &spriteHitID);
+ _res = Py_BuildValue("ll",
+ _rv,
+ spriteHitID);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaHitTestOneSprite(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID spriteID;
+ long flags;
+ Point loc;
+ Boolean wasHit;
+ if (!PyArg_ParseTuple(_args, "O&llO&",
+ CmpInstObj_Convert, &mh,
+ &spriteID,
+ &flags,
+ PyMac_GetPoint, &loc))
+ return NULL;
+ _rv = SpriteMediaHitTestOneSprite(mh,
+ spriteID,
+ flags,
+ loc,
+ &wasHit);
+ _res = Py_BuildValue("lb",
+ _rv,
+ wasHit);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaSpriteIndexToID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short spriteIndex;
+ QTAtomID spriteID;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ CmpInstObj_Convert, &mh,
+ &spriteIndex))
+ return NULL;
+ _rv = SpriteMediaSpriteIndexToID(mh,
+ spriteIndex,
+ &spriteID);
+ _res = Py_BuildValue("ll",
+ _rv,
+ spriteID);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaSpriteIDToIndex(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID spriteID;
+ short spriteIndex;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &spriteID))
+ return NULL;
+ _rv = SpriteMediaSpriteIDToIndex(mh,
+ spriteID,
+ &spriteIndex);
+ _res = Py_BuildValue("lh",
+ _rv,
+ spriteIndex);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaSetActionVariable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID variableID;
+ float value;
+ if (!PyArg_ParseTuple(_args, "O&lf",
+ CmpInstObj_Convert, &mh,
+ &variableID,
+ &value))
+ return NULL;
+ _rv = SpriteMediaSetActionVariable(mh,
+ variableID,
+ &value);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaGetActionVariable(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID variableID;
+ float value;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &variableID))
+ return NULL;
+ _rv = SpriteMediaGetActionVariable(mh,
+ variableID,
+ &value);
+ _res = Py_BuildValue("lf",
+ _rv,
+ value);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Qt_SpriteMediaGetIndImageProperty(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short imageIndex;
+ long imagePropertyType;
+ void * imagePropertyValue;
+ if (!PyArg_ParseTuple(_args, "O&hls",
+ CmpInstObj_Convert, &mh,
+ &imageIndex,
+ &imagePropertyType,
+ &imagePropertyValue))
+ return NULL;
+ _rv = SpriteMediaGetIndImageProperty(mh,
+ imageIndex,
+ imagePropertyType,
+ imagePropertyValue);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *Qt_SpriteMediaDisposeSprite(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID spriteID;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &spriteID))
+ return NULL;
+ _rv = SpriteMediaDisposeSprite(mh,
+ spriteID);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaSetActionVariableToString(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID variableID;
+ Ptr theCString;
+ if (!PyArg_ParseTuple(_args, "O&ls",
+ CmpInstObj_Convert, &mh,
+ &variableID,
+ &theCString))
+ return NULL;
+ _rv = SpriteMediaSetActionVariableToString(mh,
+ variableID,
+ theCString);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_SpriteMediaGetActionVariableAsString(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID variableID;
+ Handle theCString;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &variableID))
+ return NULL;
+ _rv = SpriteMediaGetActionVariableAsString(mh,
+ variableID,
+ &theCString);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ ResObj_New, theCString);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaSetPan(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short xPercent;
+ short yPercent;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ CmpInstObj_Convert, &mh,
+ &xPercent,
+ &yPercent))
+ return NULL;
+ _rv = FlashMediaSetPan(mh,
+ xPercent,
+ yPercent);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaSetZoom(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ short factor;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ CmpInstObj_Convert, &mh,
+ &factor))
+ return NULL;
+ _rv = FlashMediaSetZoom(mh,
+ factor);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaSetZoomRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long left;
+ long top;
+ long right;
+ long bottom;
+ if (!PyArg_ParseTuple(_args, "O&llll",
+ CmpInstObj_Convert, &mh,
+ &left,
+ &top,
+ &right,
+ &bottom))
+ return NULL;
+ _rv = FlashMediaSetZoomRect(mh,
+ left,
+ top,
+ right,
+ bottom);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaGetRefConBounds(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long refCon;
+ long left;
+ long top;
+ long right;
+ long bottom;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &refCon))
+ return NULL;
+ _rv = FlashMediaGetRefConBounds(mh,
+ refCon,
+ &left,
+ &top,
+ &right,
+ &bottom);
+ _res = Py_BuildValue("lllll",
+ _rv,
+ left,
+ top,
+ right,
+ bottom);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaGetRefConID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long refCon;
+ long refConID;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &refCon))
+ return NULL;
+ _rv = FlashMediaGetRefConID(mh,
+ refCon,
+ &refConID);
+ _res = Py_BuildValue("ll",
+ _rv,
+ refConID);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaIDToRefCon(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long refConID;
+ long refCon;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &refConID))
+ return NULL;
+ _rv = FlashMediaIDToRefCon(mh,
+ refConID,
+ &refCon);
+ _res = Py_BuildValue("ll",
+ _rv,
+ refCon);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaGetDisplayedFrameNumber(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long flashFrameNumber;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mh))
+ return NULL;
+ _rv = FlashMediaGetDisplayedFrameNumber(mh,
+ &flashFrameNumber);
+ _res = Py_BuildValue("ll",
+ _rv,
+ flashFrameNumber);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaFrameNumberToMovieTime(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long flashFrameNumber;
+ TimeValue movieTime;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &flashFrameNumber))
+ return NULL;
+ _rv = FlashMediaFrameNumberToMovieTime(mh,
+ flashFrameNumber,
+ &movieTime);
+ _res = Py_BuildValue("ll",
+ _rv,
+ movieTime);
+ return _res;
+}
+
+static PyObject *Qt_FlashMediaFrameLabelToMovieTime(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ Ptr theLabel;
+ TimeValue movieTime;
+ if (!PyArg_ParseTuple(_args, "O&s",
+ CmpInstObj_Convert, &mh,
+ &theLabel))
+ return NULL;
+ _rv = FlashMediaFrameLabelToMovieTime(mh,
+ theLabel,
+ &movieTime);
+ _res = Py_BuildValue("ll",
+ _rv,
+ movieTime);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Qt_MovieMediaGetCurrentMovieProperty(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ OSType whichProperty;
+ void * value;
+ if (!PyArg_ParseTuple(_args, "O&O&s",
+ CmpInstObj_Convert, &mh,
+ PyMac_GetOSType, &whichProperty,
+ &value))
+ return NULL;
+ _rv = MovieMediaGetCurrentMovieProperty(mh,
+ whichProperty,
+ value);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Qt_MovieMediaGetCurrentTrackProperty(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ long trackID;
+ OSType whichProperty;
+ void * value;
+ if (!PyArg_ParseTuple(_args, "O&lO&s",
+ CmpInstObj_Convert, &mh,
+ &trackID,
+ PyMac_GetOSType, &whichProperty,
+ &value))
+ return NULL;
+ _rv = MovieMediaGetCurrentTrackProperty(mh,
+ trackID,
+ whichProperty,
+ value);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Qt_MovieMediaGetChildMovieDataReference(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID dataRefID;
+ short dataRefIndex;
+ OSType dataRefType;
+ Handle dataRef;
+ QTAtomID dataRefIDOut;
+ short dataRefIndexOut;
+ if (!PyArg_ParseTuple(_args, "O&lh",
+ CmpInstObj_Convert, &mh,
+ &dataRefID,
+ &dataRefIndex))
+ return NULL;
+ _rv = MovieMediaGetChildMovieDataReference(mh,
+ dataRefID,
+ dataRefIndex,
+ &dataRefType,
+ &dataRef,
+ &dataRefIDOut,
+ &dataRefIndexOut);
+ _res = Py_BuildValue("lO&O&lh",
+ _rv,
+ PyMac_BuildOSType, dataRefType,
+ ResObj_New, dataRef,
+ dataRefIDOut,
+ dataRefIndexOut);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Qt_MovieMediaSetChildMovieDataReference(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID dataRefID;
+ OSType dataRefType;
+ Handle dataRef;
+ if (!PyArg_ParseTuple(_args, "O&lO&O&",
+ CmpInstObj_Convert, &mh,
+ &dataRefID,
+ PyMac_GetOSType, &dataRefType,
+ ResObj_Convert, &dataRef))
+ return NULL;
+ _rv = MovieMediaSetChildMovieDataReference(mh,
+ dataRefID,
+ dataRefType,
+ dataRef);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Qt_MovieMediaLoadChildMovieFromDataReference(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTAtomID dataRefID;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mh,
+ &dataRefID))
+ return NULL;
+ _rv = MovieMediaLoadChildMovieFromDataReference(mh,
+ dataRefID);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *Qt_Media3DGetCurrentGroup(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ void * group;
+ if (!PyArg_ParseTuple(_args, "O&s",
+ CmpInstObj_Convert, &mh,
+ &group))
+ return NULL;
+ _rv = Media3DGetCurrentGroup(mh,
+ group);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_Media3DTranslateNamedObjectTo(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ char objectName;
+ Fixed x;
+ Fixed y;
+ Fixed z;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+ CmpInstObj_Convert, &mh,
+ PyMac_GetFixed, &x,
+ PyMac_GetFixed, &y,
+ PyMac_GetFixed, &z))
+ return NULL;
+ _rv = Media3DTranslateNamedObjectTo(mh,
+ &objectName,
+ x,
+ y,
+ z);
+ _res = Py_BuildValue("lc",
+ _rv,
+ objectName);
+ return _res;
+}
+
+static PyObject *Qt_Media3DScaleNamedObjectTo(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ char objectName;
+ Fixed xScale;
+ Fixed yScale;
+ Fixed zScale;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+ CmpInstObj_Convert, &mh,
+ PyMac_GetFixed, &xScale,
+ PyMac_GetFixed, &yScale,
+ PyMac_GetFixed, &zScale))
+ return NULL;
+ _rv = Media3DScaleNamedObjectTo(mh,
+ &objectName,
+ xScale,
+ yScale,
+ zScale);
+ _res = Py_BuildValue("lc",
+ _rv,
+ objectName);
+ return _res;
+}
+
+static PyObject *Qt_Media3DRotateNamedObjectTo(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ char objectName;
+ Fixed xDegrees;
+ Fixed yDegrees;
+ Fixed zDegrees;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+ CmpInstObj_Convert, &mh,
+ PyMac_GetFixed, &xDegrees,
+ PyMac_GetFixed, &yDegrees,
+ PyMac_GetFixed, &zDegrees))
+ return NULL;
+ _rv = Media3DRotateNamedObjectTo(mh,
+ &objectName,
+ xDegrees,
+ yDegrees,
+ zDegrees);
+ _res = Py_BuildValue("lc",
+ _rv,
+ objectName);
+ return _res;
+}
+
+static PyObject *Qt_Media3DSetCameraData(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ void * cameraData;
+ if (!PyArg_ParseTuple(_args, "O&s",
+ CmpInstObj_Convert, &mh,
+ &cameraData))
+ return NULL;
+ _rv = Media3DSetCameraData(mh,
+ cameraData);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_Media3DGetCameraData(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ void * cameraData;
+ if (!PyArg_ParseTuple(_args, "O&s",
+ CmpInstObj_Convert, &mh,
+ &cameraData))
+ return NULL;
+ _rv = Media3DGetCameraData(mh,
+ cameraData);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_Media3DSetCameraAngleAspect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTFloatSingle fov;
+ QTFloatSingle aspectRatioXToY;
+ if (!PyArg_ParseTuple(_args, "O&ff",
+ CmpInstObj_Convert, &mh,
+ &fov,
+ &aspectRatioXToY))
+ return NULL;
+ _rv = Media3DSetCameraAngleAspect(mh,
+ fov,
+ aspectRatioXToY);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_Media3DGetCameraAngleAspect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ QTFloatSingle fov;
+ QTFloatSingle aspectRatioXToY;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mh))
+ return NULL;
+ _rv = Media3DGetCameraAngleAspect(mh,
+ &fov,
+ &aspectRatioXToY);
+ _res = Py_BuildValue("lff",
+ _rv,
+ fov,
+ aspectRatioXToY);
+ return _res;
+}
+
+static PyObject *Qt_Media3DSetCameraRange(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ void * tQ3CameraRange;
+ if (!PyArg_ParseTuple(_args, "O&s",
+ CmpInstObj_Convert, &mh,
+ &tQ3CameraRange))
+ return NULL;
+ _rv = Media3DSetCameraRange(mh,
+ tQ3CameraRange);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_Media3DGetCameraRange(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ void * tQ3CameraRange;
+ if (!PyArg_ParseTuple(_args, "O&s",
+ CmpInstObj_Convert, &mh,
+ &tQ3CameraRange))
+ return NULL;
+ _rv = Media3DGetCameraRange(mh,
+ tQ3CameraRange);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Qt_Media3DGetViewObject(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MediaHandler mh;
+ void * tq3viewObject;
+ if (!PyArg_ParseTuple(_args, "O&s",
+ CmpInstObj_Convert, &mh,
+ &tq3viewObject))
+ return NULL;
+ _rv = Media3DGetViewObject(mh,
+ tq3viewObject);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *Qt_NewTimeBase(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeBase _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = NewTimeBase();
+ _res = Py_BuildValue("O&",
+ TimeBaseObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qt_ConvertTime(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeRecord inout;
+ TimeBase newBase;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ QtTimeRecord_Convert, &inout,
+ TimeBaseObj_Convert, &newBase))
+ return NULL;
+ ConvertTime(&inout,
+ newBase);
+ _res = Py_BuildValue("O&",
+ QtTimeRecord_New, &inout);
+ return _res;
+}
+
+static PyObject *Qt_ConvertTimeScale(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeRecord inout;
+ TimeScale newScale;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ QtTimeRecord_Convert, &inout,
+ &newScale))
+ return NULL;
+ ConvertTimeScale(&inout,
+ newScale);
+ _res = Py_BuildValue("O&",
+ QtTimeRecord_New, &inout);
+ return _res;
+}
+
+static PyObject *Qt_AddTime(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeRecord dst;
+ TimeRecord src;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ QtTimeRecord_Convert, &dst,
+ QtTimeRecord_Convert, &src))
+ return NULL;
+ AddTime(&dst,
+ &src);
+ _res = Py_BuildValue("O&",
+ QtTimeRecord_New, &dst);
+ return _res;
+}
+
+static PyObject *Qt_SubtractTime(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TimeRecord dst;
+ TimeRecord src;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ QtTimeRecord_Convert, &dst,
+ QtTimeRecord_Convert, &src))
+ return NULL;
+ SubtractTime(&dst,
+ &src);
+ _res = Py_BuildValue("O&",
+ QtTimeRecord_New, &dst);
+ return _res;
+}
+
+static PyObject *Qt_MusicMediaGetIndexedTunePlayer(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ ComponentInstance ti;
+ long sampleDescIndex;
+ ComponentInstance tp;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &ti,
+ &sampleDescIndex))
+ return NULL;
+ _rv = MusicMediaGetIndexedTunePlayer(ti,
+ sampleDescIndex,
+ &tp);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ CmpInstObj_New, tp);
+ return _res;
+}
+
+static PyObject *Qt_AlignWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr wp;
+ Boolean front;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ WinObj_Convert, &wp,
+ &front))
+ return NULL;
+ AlignWindow(wp,
+ front,
+ (Rect *)0,
+ (ICMAlignmentProcRecordPtr)0);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_DragAlignedWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr wp;
+ Point startPt;
+ Rect boundsRect;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ WinObj_Convert, &wp,
+ PyMac_GetPoint, &startPt,
+ PyMac_GetRect, &boundsRect))
+ return NULL;
+ DragAlignedWindow(wp,
+ startPt,
+ &boundsRect,
+ (Rect *)0,
+ (ICMAlignmentProcRecordPtr)0);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qt_MoviesTask(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long maxMilliSecToUse;
+ if (!PyArg_ParseTuple(_args, "l",
+ &maxMilliSecToUse))
+ return NULL;
+ MoviesTask((Movie)0,
+ maxMilliSecToUse);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef Qt_methods[] = {
+
+#if !TARGET_API_MAC_CARBON
+ {"CheckQuickTimeRegistration", (PyCFunction)Qt_CheckQuickTimeRegistration, 1,
+ "(void * registrationKey, long flags) -> None"},
+#endif
+ {"EnterMovies", (PyCFunction)Qt_EnterMovies, 1,
+ "() -> None"},
+ {"ExitMovies", (PyCFunction)Qt_ExitMovies, 1,
+ "() -> None"},
+ {"GetMoviesError", (PyCFunction)Qt_GetMoviesError, 1,
+ "() -> None"},
+ {"ClearMoviesStickyError", (PyCFunction)Qt_ClearMoviesStickyError, 1,
+ "() -> None"},
+ {"GetMoviesStickyError", (PyCFunction)Qt_GetMoviesStickyError, 1,
+ "() -> None"},
+ {"DisposeMatte", (PyCFunction)Qt_DisposeMatte, 1,
+ "(PixMapHandle theMatte) -> None"},
+ {"NewMovie", (PyCFunction)Qt_NewMovie, 1,
+ "(long flags) -> (Movie _rv)"},
+ {"GetDataHandler", (PyCFunction)Qt_GetDataHandler, 1,
+ "(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"OpenADataHandler", (PyCFunction)Qt_OpenADataHandler, 1,
+ "(Handle dataRef, OSType dataHandlerSubType, Handle anchorDataRef, OSType anchorDataRefType, TimeBase tb, long flags) -> (ComponentInstance dh)"},
+#endif
+ {"PasteHandleIntoMovie", (PyCFunction)Qt_PasteHandleIntoMovie, 1,
+ "(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None"},
+ {"GetMovieImporterForDataRef", (PyCFunction)Qt_GetMovieImporterForDataRef, 1,
+ "(OSType dataRefType, Handle dataRef, long flags) -> (Component importer)"},
+ {"TrackTimeToMediaTime", (PyCFunction)Qt_TrackTimeToMediaTime, 1,
+ "(TimeValue value, Track theTrack) -> (TimeValue _rv)"},
+ {"NewUserData", (PyCFunction)Qt_NewUserData, 1,
+ "() -> (UserData theUserData)"},
+ {"NewUserDataFromHandle", (PyCFunction)Qt_NewUserDataFromHandle, 1,
+ "(Handle h) -> (UserData theUserData)"},
+ {"CreateMovieFile", (PyCFunction)Qt_CreateMovieFile, 1,
+ "(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (short resRefNum, Movie newmovie)"},
+ {"OpenMovieFile", (PyCFunction)Qt_OpenMovieFile, 1,
+ "(FSSpec fileSpec, SInt8 permission) -> (short resRefNum)"},
+ {"CloseMovieFile", (PyCFunction)Qt_CloseMovieFile, 1,
+ "(short resRefNum) -> None"},
+ {"DeleteMovieFile", (PyCFunction)Qt_DeleteMovieFile, 1,
+ "(FSSpec fileSpec) -> None"},
+ {"NewMovieFromFile", (PyCFunction)Qt_NewMovieFromFile, 1,
+ "(short resRefNum, short resId, short newMovieFlags) -> (Movie theMovie, short resId, Boolean dataRefWasChanged)"},
+ {"NewMovieFromHandle", (PyCFunction)Qt_NewMovieFromHandle, 1,
+ "(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
+ {"NewMovieFromDataFork", (PyCFunction)Qt_NewMovieFromDataFork, 1,
+ "(short fRefNum, long fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
+ {"NewMovieFromDataFork64", (PyCFunction)Qt_NewMovieFromDataFork64, 1,
+ "(long fRefNum, wide fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
+ {"NewMovieFromDataRef", (PyCFunction)Qt_NewMovieFromDataRef, 1,
+ "(short flags, Handle dataRef, OSType dataRefType) -> (Movie m, short id)"},
+ {"RemoveMovieResource", (PyCFunction)Qt_RemoveMovieResource, 1,
+ "(short resRefNum, short resId) -> None"},
+ {"CreateShortcutMovieFile", (PyCFunction)Qt_CreateShortcutMovieFile, 1,
+ "(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Handle targetDataRef, OSType targetDataRefType) -> None"},
+ {"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1,
+ "(long newMovieFlags) -> (Movie _rv)"},
+ {"QTNewAlias", (PyCFunction)Qt_QTNewAlias, 1,
+ "(FSSpec fss, Boolean minimal) -> (AliasHandle alias)"},
+ {"EndFullScreen", (PyCFunction)Qt_EndFullScreen, 1,
+ "(Ptr fullState, long flags) -> None"},
+ {"AddSoundDescriptionExtension", (PyCFunction)Qt_AddSoundDescriptionExtension, 1,
+ "(SoundDescriptionHandle desc, Handle extension, OSType idType) -> None"},
+ {"GetSoundDescriptionExtension", (PyCFunction)Qt_GetSoundDescriptionExtension, 1,
+ "(SoundDescriptionHandle desc, OSType idType) -> (Handle extension)"},
+ {"RemoveSoundDescriptionExtension", (PyCFunction)Qt_RemoveSoundDescriptionExtension, 1,
+ "(SoundDescriptionHandle desc, OSType idType) -> None"},
+ {"QTIsStandardParameterDialogEvent", (PyCFunction)Qt_QTIsStandardParameterDialogEvent, 1,
+ "(QTParameterDialog createdDialog) -> (EventRecord pEvent)"},
+ {"QTDismissStandardParameterDialog", (PyCFunction)Qt_QTDismissStandardParameterDialog, 1,
+ "(QTParameterDialog createdDialog) -> None"},
+ {"QTStandardParameterDialogDoAction", (PyCFunction)Qt_QTStandardParameterDialogDoAction, 1,
+ "(QTParameterDialog createdDialog, long action, void * params) -> None"},
+ {"QTRegisterAccessKey", (PyCFunction)Qt_QTRegisterAccessKey, 1,
+ "(Str255 accessKeyType, long flags, Handle accessKey) -> None"},
+ {"QTUnregisterAccessKey", (PyCFunction)Qt_QTUnregisterAccessKey, 1,
+ "(Str255 accessKeyType, long flags, Handle accessKey) -> None"},
+ {"QTTextToNativeText", (PyCFunction)Qt_QTTextToNativeText, 1,
+ "(Handle theText, long encoding, long flags) -> None"},
+ {"VideoMediaResetStatistics", (PyCFunction)Qt_VideoMediaResetStatistics, 1,
+ "(MediaHandler mh) -> (ComponentResult _rv)"},
+ {"VideoMediaGetStatistics", (PyCFunction)Qt_VideoMediaGetStatistics, 1,
+ "(MediaHandler mh) -> (ComponentResult _rv)"},
+ {"VideoMediaGetStallCount", (PyCFunction)Qt_VideoMediaGetStallCount, 1,
+ "(MediaHandler mh) -> (ComponentResult _rv, unsigned long stalls)"},
+ {"VideoMediaSetCodecParameter", (PyCFunction)Qt_VideoMediaSetCodecParameter, 1,
+ "(MediaHandler mh, CodecType cType, OSType parameterID, long parameterChangeSeed, void * dataPtr, long dataSize) -> (ComponentResult _rv)"},
+ {"VideoMediaGetCodecParameter", (PyCFunction)Qt_VideoMediaGetCodecParameter, 1,
+ "(MediaHandler mh, CodecType cType, OSType parameterID, Handle outParameterData) -> (ComponentResult _rv)"},
+ {"TextMediaAddTextSample", (PyCFunction)Qt_TextMediaAddTextSample, 1,
+ "(MediaHandler mh, Ptr text, unsigned long size, short fontNumber, short fontSize, Style textFace, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor textColor, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)"},
+ {"TextMediaAddTESample", (PyCFunction)Qt_TextMediaAddTESample, 1,
+ "(MediaHandler mh, TEHandle hTE, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)"},
+ {"TextMediaAddHiliteSample", (PyCFunction)Qt_TextMediaAddHiliteSample, 1,
+ "(MediaHandler mh, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor rgbHiliteColor, TimeValue sampleTime)"},
+ {"TextMediaDrawRaw", (PyCFunction)Qt_TextMediaDrawRaw, 1,
+ "(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh) -> (ComponentResult _rv)"},
+ {"TextMediaSetTextProperty", (PyCFunction)Qt_TextMediaSetTextProperty, 1,
+ "(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)"},
+ {"TextMediaRawSetup", (PyCFunction)Qt_TextMediaRawSetup, 1,
+ "(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh, TimeValue sampleDuration) -> (ComponentResult _rv)"},
+ {"TextMediaRawIdle", (PyCFunction)Qt_TextMediaRawIdle, 1,
+ "(MediaHandler mh, GWorldPtr gw, GDHandle gd, TimeValue sampleTime, long flagsIn) -> (ComponentResult _rv, long flagsOut)"},
+ {"TextMediaFindNextText", (PyCFunction)Qt_TextMediaFindNextText, 1,
+ "(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)"},
+ {"TextMediaHiliteTextSample", (PyCFunction)Qt_TextMediaHiliteTextSample, 1,
+ "(MediaHandler mh, TimeValue sampleTime, short hiliteStart, short hiliteEnd) -> (ComponentResult _rv, RGBColor rgbHiliteColor)"},
+ {"TextMediaSetTextSampleData", (PyCFunction)Qt_TextMediaSetTextSampleData, 1,
+ "(MediaHandler mh, void * data, OSType dataType) -> (ComponentResult _rv)"},
+ {"SpriteMediaSetProperty", (PyCFunction)Qt_SpriteMediaSetProperty, 1,
+ "(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
+ {"SpriteMediaGetProperty", (PyCFunction)Qt_SpriteMediaGetProperty, 1,
+ "(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
+ {"SpriteMediaHitTestSprites", (PyCFunction)Qt_SpriteMediaHitTestSprites, 1,
+ "(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, short spriteHitIndex)"},
+ {"SpriteMediaCountSprites", (PyCFunction)Qt_SpriteMediaCountSprites, 1,
+ "(MediaHandler mh) -> (ComponentResult _rv, short numSprites)"},
+ {"SpriteMediaCountImages", (PyCFunction)Qt_SpriteMediaCountImages, 1,
+ "(MediaHandler mh) -> (ComponentResult _rv, short numImages)"},
+ {"SpriteMediaGetIndImageDescription", (PyCFunction)Qt_SpriteMediaGetIndImageDescription, 1,
+ "(MediaHandler mh, short imageIndex, ImageDescriptionHandle imageDescription) -> (ComponentResult _rv)"},
+ {"SpriteMediaGetDisplayedSampleNumber", (PyCFunction)Qt_SpriteMediaGetDisplayedSampleNumber, 1,
+ "(MediaHandler mh) -> (ComponentResult _rv, long sampleNum)"},
+ {"SpriteMediaGetSpriteName", (PyCFunction)Qt_SpriteMediaGetSpriteName, 1,
+ "(MediaHandler mh, QTAtomID spriteID, Str255 spriteName) -> (ComponentResult _rv)"},
+ {"SpriteMediaGetImageName", (PyCFunction)Qt_SpriteMediaGetImageName, 1,
+ "(MediaHandler mh, short imageIndex, Str255 imageName) -> (ComponentResult _rv)"},
+ {"SpriteMediaSetSpriteProperty", (PyCFunction)Qt_SpriteMediaSetSpriteProperty, 1,
+ "(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
+ {"SpriteMediaGetSpriteProperty", (PyCFunction)Qt_SpriteMediaGetSpriteProperty, 1,
+ "(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
+ {"SpriteMediaHitTestAllSprites", (PyCFunction)Qt_SpriteMediaHitTestAllSprites, 1,
+ "(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, QTAtomID spriteHitID)"},
+ {"SpriteMediaHitTestOneSprite", (PyCFunction)Qt_SpriteMediaHitTestOneSprite, 1,
+ "(MediaHandler mh, QTAtomID spriteID, long flags, Point loc) -> (ComponentResult _rv, Boolean wasHit)"},
+ {"SpriteMediaSpriteIndexToID", (PyCFunction)Qt_SpriteMediaSpriteIndexToID, 1,
+ "(MediaHandler mh, short spriteIndex) -> (ComponentResult _rv, QTAtomID spriteID)"},
+ {"SpriteMediaSpriteIDToIndex", (PyCFunction)Qt_SpriteMediaSpriteIDToIndex, 1,
+ "(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv, short spriteIndex)"},
+ {"SpriteMediaSetActionVariable", (PyCFunction)Qt_SpriteMediaSetActionVariable, 1,
+ "(MediaHandler mh, QTAtomID variableID, float value) -> (ComponentResult _rv)"},
+ {"SpriteMediaGetActionVariable", (PyCFunction)Qt_SpriteMediaGetActionVariable, 1,
+ "(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, float value)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"SpriteMediaGetIndImageProperty", (PyCFunction)Qt_SpriteMediaGetIndImageProperty, 1,
+ "(MediaHandler mh, short imageIndex, long imagePropertyType, void * imagePropertyValue) -> (ComponentResult _rv)"},
+#endif
+ {"SpriteMediaDisposeSprite", (PyCFunction)Qt_SpriteMediaDisposeSprite, 1,
+ "(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv)"},
+ {"SpriteMediaSetActionVariableToString", (PyCFunction)Qt_SpriteMediaSetActionVariableToString, 1,
+ "(MediaHandler mh, QTAtomID variableID, Ptr theCString) -> (ComponentResult _rv)"},
+ {"SpriteMediaGetActionVariableAsString", (PyCFunction)Qt_SpriteMediaGetActionVariableAsString, 1,
+ "(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, Handle theCString)"},
+ {"FlashMediaSetPan", (PyCFunction)Qt_FlashMediaSetPan, 1,
+ "(MediaHandler mh, short xPercent, short yPercent) -> (ComponentResult _rv)"},
+ {"FlashMediaSetZoom", (PyCFunction)Qt_FlashMediaSetZoom, 1,
+ "(MediaHandler mh, short factor) -> (ComponentResult _rv)"},
+ {"FlashMediaSetZoomRect", (PyCFunction)Qt_FlashMediaSetZoomRect, 1,
+ "(MediaHandler mh, long left, long top, long right, long bottom) -> (ComponentResult _rv)"},
+ {"FlashMediaGetRefConBounds", (PyCFunction)Qt_FlashMediaGetRefConBounds, 1,
+ "(MediaHandler mh, long refCon) -> (ComponentResult _rv, long left, long top, long right, long bottom)"},
+ {"FlashMediaGetRefConID", (PyCFunction)Qt_FlashMediaGetRefConID, 1,
+ "(MediaHandler mh, long refCon) -> (ComponentResult _rv, long refConID)"},
+ {"FlashMediaIDToRefCon", (PyCFunction)Qt_FlashMediaIDToRefCon, 1,
+ "(MediaHandler mh, long refConID) -> (ComponentResult _rv, long refCon)"},
+ {"FlashMediaGetDisplayedFrameNumber", (PyCFunction)Qt_FlashMediaGetDisplayedFrameNumber, 1,
+ "(MediaHandler mh) -> (ComponentResult _rv, long flashFrameNumber)"},
+ {"FlashMediaFrameNumberToMovieTime", (PyCFunction)Qt_FlashMediaFrameNumberToMovieTime, 1,
+ "(MediaHandler mh, long flashFrameNumber) -> (ComponentResult _rv, TimeValue movieTime)"},
+ {"FlashMediaFrameLabelToMovieTime", (PyCFunction)Qt_FlashMediaFrameLabelToMovieTime, 1,
+ "(MediaHandler mh, Ptr theLabel) -> (ComponentResult _rv, TimeValue movieTime)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"MovieMediaGetCurrentMovieProperty", (PyCFunction)Qt_MovieMediaGetCurrentMovieProperty, 1,
+ "(MediaHandler mh, OSType whichProperty, void * value) -> (ComponentResult _rv)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"MovieMediaGetCurrentTrackProperty", (PyCFunction)Qt_MovieMediaGetCurrentTrackProperty, 1,
+ "(MediaHandler mh, long trackID, OSType whichProperty, void * value) -> (ComponentResult _rv)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"MovieMediaGetChildMovieDataReference", (PyCFunction)Qt_MovieMediaGetChildMovieDataReference, 1,
+ "(MediaHandler mh, QTAtomID dataRefID, short dataRefIndex) -> (ComponentResult _rv, OSType dataRefType, Handle dataRef, QTAtomID dataRefIDOut, short dataRefIndexOut)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"MovieMediaSetChildMovieDataReference", (PyCFunction)Qt_MovieMediaSetChildMovieDataReference, 1,
+ "(MediaHandler mh, QTAtomID dataRefID, OSType dataRefType, Handle dataRef) -> (ComponentResult _rv)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"MovieMediaLoadChildMovieFromDataReference", (PyCFunction)Qt_MovieMediaLoadChildMovieFromDataReference, 1,
+ "(MediaHandler mh, QTAtomID dataRefID) -> (ComponentResult _rv)"},
+#endif
+ {"Media3DGetCurrentGroup", (PyCFunction)Qt_Media3DGetCurrentGroup, 1,
+ "(MediaHandler mh, void * group) -> (ComponentResult _rv)"},
+ {"Media3DTranslateNamedObjectTo", (PyCFunction)Qt_Media3DTranslateNamedObjectTo, 1,
+ "(MediaHandler mh, Fixed x, Fixed y, Fixed z) -> (ComponentResult _rv, char objectName)"},
+ {"Media3DScaleNamedObjectTo", (PyCFunction)Qt_Media3DScaleNamedObjectTo, 1,
+ "(MediaHandler mh, Fixed xScale, Fixed yScale, Fixed zScale) -> (ComponentResult _rv, char objectName)"},
+ {"Media3DRotateNamedObjectTo", (PyCFunction)Qt_Media3DRotateNamedObjectTo, 1,
+ "(MediaHandler mh, Fixed xDegrees, Fixed yDegrees, Fixed zDegrees) -> (ComponentResult _rv, char objectName)"},
+ {"Media3DSetCameraData", (PyCFunction)Qt_Media3DSetCameraData, 1,
+ "(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)"},
+ {"Media3DGetCameraData", (PyCFunction)Qt_Media3DGetCameraData, 1,
+ "(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)"},
+ {"Media3DSetCameraAngleAspect", (PyCFunction)Qt_Media3DSetCameraAngleAspect, 1,
+ "(MediaHandler mh, QTFloatSingle fov, QTFloatSingle aspectRatioXToY) -> (ComponentResult _rv)"},
+ {"Media3DGetCameraAngleAspect", (PyCFunction)Qt_Media3DGetCameraAngleAspect, 1,
+ "(MediaHandler mh) -> (ComponentResult _rv, QTFloatSingle fov, QTFloatSingle aspectRatioXToY)"},
+ {"Media3DSetCameraRange", (PyCFunction)Qt_Media3DSetCameraRange, 1,
+ "(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)"},
+ {"Media3DGetCameraRange", (PyCFunction)Qt_Media3DGetCameraRange, 1,
+ "(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"Media3DGetViewObject", (PyCFunction)Qt_Media3DGetViewObject, 1,
+ "(MediaHandler mh, void * tq3viewObject) -> (ComponentResult _rv)"},
+#endif
+ {"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1,
+ "() -> (TimeBase _rv)"},
+ {"ConvertTime", (PyCFunction)Qt_ConvertTime, 1,
+ "(TimeRecord inout, TimeBase newBase) -> (TimeRecord inout)"},
+ {"ConvertTimeScale", (PyCFunction)Qt_ConvertTimeScale, 1,
+ "(TimeRecord inout, TimeScale newScale) -> (TimeRecord inout)"},
+ {"AddTime", (PyCFunction)Qt_AddTime, 1,
+ "(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)"},
+ {"SubtractTime", (PyCFunction)Qt_SubtractTime, 1,
+ "(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)"},
+ {"MusicMediaGetIndexedTunePlayer", (PyCFunction)Qt_MusicMediaGetIndexedTunePlayer, 1,
+ "(ComponentInstance ti, long sampleDescIndex) -> (ComponentResult _rv, ComponentInstance tp)"},
+ {"AlignWindow", (PyCFunction)Qt_AlignWindow, 1,
+ "(WindowPtr wp, Boolean front) -> None"},
+ {"DragAlignedWindow", (PyCFunction)Qt_DragAlignedWindow, 1,
+ "(WindowPtr wp, Point startPt, Rect boundsRect) -> None"},
+ {"MoviesTask", (PyCFunction)Qt_MoviesTask, 1,
+ "(long maxMilliSecToUse) -> None"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_Qt(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(Track, TrackObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Track, TrackObj_Convert);
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(Movie, MovieObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Movie, MovieObj_Convert);
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(MovieController, MovieCtlObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(MovieController, MovieCtlObj_Convert);
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(TimeBase, TimeBaseObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(TimeBase, TimeBaseObj_Convert);
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(UserData, UserDataObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(UserData, UserDataObj_Convert);
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(Media, MediaObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Media, MediaObj_Convert);
+
+
+ m = Py_InitModule("_Qt", Qt_methods);
+ d = PyModule_GetDict(m);
+ Qt_Error = PyMac_GetOSErrException();
+ if (Qt_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Qt_Error) != 0)
+ return;
+ MovieController_Type.ob_type = &PyType_Type;
+ Py_INCREF(&MovieController_Type);
+ if (PyDict_SetItemString(d, "MovieControllerType", (PyObject *)&MovieController_Type) != 0)
+ Py_FatalError("can't initialize MovieControllerType");
+ TimeBase_Type.ob_type = &PyType_Type;
+ Py_INCREF(&TimeBase_Type);
+ if (PyDict_SetItemString(d, "TimeBaseType", (PyObject *)&TimeBase_Type) != 0)
+ Py_FatalError("can't initialize TimeBaseType");
+ UserData_Type.ob_type = &PyType_Type;
+ Py_INCREF(&UserData_Type);
+ if (PyDict_SetItemString(d, "UserDataType", (PyObject *)&UserData_Type) != 0)
+ Py_FatalError("can't initialize UserDataType");
+ Media_Type.ob_type = &PyType_Type;
+ Py_INCREF(&Media_Type);
+ if (PyDict_SetItemString(d, "MediaType", (PyObject *)&Media_Type) != 0)
+ Py_FatalError("can't initialize MediaType");
+ Track_Type.ob_type = &PyType_Type;
+ Py_INCREF(&Track_Type);
+ if (PyDict_SetItemString(d, "TrackType", (PyObject *)&Track_Type) != 0)
+ Py_FatalError("can't initialize TrackType");
+ Movie_Type.ob_type = &PyType_Type;
+ Py_INCREF(&Movie_Type);
+ if (PyDict_SetItemString(d, "MovieType", (PyObject *)&Movie_Type) != 0)
+ Py_FatalError("can't initialize MovieType");
+}
+
+/* ========================= End module _Qt ========================= */
+
--- /dev/null
+
+/* ========================== Module _Res =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Resources.h>
+#include <string.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+extern PyObject *_ResObj_New(Handle);
+extern int _ResObj_Convert(PyObject *, Handle *);
+extern PyObject *_OptResObj_New(Handle);
+extern int _OptResObj_Convert(PyObject *, Handle *);
+#define ResObj_New _ResObj_New
+#define ResObj_Convert _ResObj_Convert
+#define OptResObj_New _OptResObj_New
+#define OptResObj_Convert _OptResObj_Convert
+#endif
+
+/* Function to dispose a resource, with a "normal" calling sequence */
+static void
+PyMac_AutoDisposeHandle(Handle h)
+{
+ DisposeHandle(h);
+}
+
+static PyObject *Res_Error;
+
+/* ---------------------- Object type Resource ---------------------- */
+
+PyTypeObject Resource_Type;
+
+#define ResObj_Check(x) ((x)->ob_type == &Resource_Type)
+
+typedef struct ResourceObject {
+ PyObject_HEAD
+ Handle ob_itself;
+ void (*ob_freeit)(Handle ptr);
+} ResourceObject;
+
+PyObject *ResObj_New(Handle itself)
+{
+ ResourceObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(ResourceObject, &Resource_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_freeit = NULL;
+ return (PyObject *)it;
+}
+ResObj_Convert(PyObject *v, Handle *p_itself)
+{
+ if (!ResObj_Check(v))
+ {
+ PyObject *tmp;
+ if ( (tmp=PyObject_CallMethod(v, "as_Resource", "")) )
+ {
+ *p_itself = ((ResourceObject *)tmp)->ob_itself;
+ Py_DECREF(tmp);
+ return 1;
+ }
+ PyErr_Clear();
+ }
+ if (!ResObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "Resource required");
+ return 0;
+ }
+ *p_itself = ((ResourceObject *)v)->ob_itself;
+ return 1;
+}
+
+static void ResObj_dealloc(ResourceObject *self)
+{
+ if (self->ob_freeit && self->ob_itself)
+ {
+ self->ob_freeit(self->ob_itself);
+ }
+ self->ob_itself = NULL;
+ PyMem_DEL(self);
+}
+
+static PyObject *ResObj_HomeResFile(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = HomeResFile(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *ResObj_MacLoadResource(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ MacLoadResource(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_ReleaseResource(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ReleaseResource(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_DetachResource(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DetachResource(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_GetResAttrs(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetResAttrs(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *ResObj_GetResInfo(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short theID;
+ ResType theType;
+ Str255 name;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetResInfo(_self->ob_itself,
+ &theID,
+ &theType,
+ name);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("hO&O&",
+ theID,
+ PyMac_BuildOSType, theType,
+ PyMac_BuildStr255, name);
+ return _res;
+}
+
+static PyObject *ResObj_SetResInfo(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short theID;
+ Str255 name;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &theID,
+ PyMac_GetStr255, name))
+ return NULL;
+ SetResInfo(_self->ob_itself,
+ theID,
+ name);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_AddResource(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ResType theType;
+ short theID;
+ Str255 name;
+ if (!PyArg_ParseTuple(_args, "O&hO&",
+ PyMac_GetOSType, &theType,
+ &theID,
+ PyMac_GetStr255, name))
+ return NULL;
+ AddResource(_self->ob_itself,
+ theType,
+ theID,
+ name);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_GetResourceSizeOnDisk(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetResourceSizeOnDisk(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *ResObj_GetMaxResourceSize(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMaxResourceSize(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+#if TARGET_API_MAC_OS8
+
+static PyObject *ResObj_RsrcMapEntry(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = RsrcMapEntry(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *ResObj_SetResAttrs(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short attrs;
+ if (!PyArg_ParseTuple(_args, "h",
+ &attrs))
+ return NULL;
+ SetResAttrs(_self->ob_itself,
+ attrs);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_ChangedResource(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ChangedResource(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_RemoveResource(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ RemoveResource(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_WriteResource(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ WriteResource(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_SetResourceSize(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long newSize;
+ if (!PyArg_ParseTuple(_args, "l",
+ &newSize))
+ return NULL;
+ SetResourceSize(_self->ob_itself,
+ newSize);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_GetNextFOND(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetNextFOND(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *ResObj_as_Control(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ return CtlObj_New((ControlHandle)_self->ob_itself);
+
+}
+
+static PyObject *ResObj_as_Menu(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ return MenuObj_New((MenuHandle)_self->ob_itself);
+
+}
+
+static PyObject *ResObj_LoadResource(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ LoadResource(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_AutoDispose(ResourceObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ int onoff, old = 0;
+ if (!PyArg_ParseTuple(_args, "i", &onoff))
+ return NULL;
+ if ( _self->ob_freeit )
+ old = 1;
+ if ( onoff )
+ _self->ob_freeit = PyMac_AutoDisposeHandle;
+ else
+ _self->ob_freeit = NULL;
+ return Py_BuildValue("i", old);
+
+}
+
+static PyMethodDef ResObj_methods[] = {
+ {"HomeResFile", (PyCFunction)ResObj_HomeResFile, 1,
+ "() -> (short _rv)"},
+ {"MacLoadResource", (PyCFunction)ResObj_MacLoadResource, 1,
+ "() -> None"},
+ {"ReleaseResource", (PyCFunction)ResObj_ReleaseResource, 1,
+ "() -> None"},
+ {"DetachResource", (PyCFunction)ResObj_DetachResource, 1,
+ "() -> None"},
+ {"GetResAttrs", (PyCFunction)ResObj_GetResAttrs, 1,
+ "() -> (short _rv)"},
+ {"GetResInfo", (PyCFunction)ResObj_GetResInfo, 1,
+ "() -> (short theID, ResType theType, Str255 name)"},
+ {"SetResInfo", (PyCFunction)ResObj_SetResInfo, 1,
+ "(short theID, Str255 name) -> None"},
+ {"AddResource", (PyCFunction)ResObj_AddResource, 1,
+ "(ResType theType, short theID, Str255 name) -> None"},
+ {"GetResourceSizeOnDisk", (PyCFunction)ResObj_GetResourceSizeOnDisk, 1,
+ "() -> (long _rv)"},
+ {"GetMaxResourceSize", (PyCFunction)ResObj_GetMaxResourceSize, 1,
+ "() -> (long _rv)"},
+
+#if TARGET_API_MAC_OS8
+ {"RsrcMapEntry", (PyCFunction)ResObj_RsrcMapEntry, 1,
+ "() -> (long _rv)"},
+#endif
+ {"SetResAttrs", (PyCFunction)ResObj_SetResAttrs, 1,
+ "(short attrs) -> None"},
+ {"ChangedResource", (PyCFunction)ResObj_ChangedResource, 1,
+ "() -> None"},
+ {"RemoveResource", (PyCFunction)ResObj_RemoveResource, 1,
+ "() -> None"},
+ {"WriteResource", (PyCFunction)ResObj_WriteResource, 1,
+ "() -> None"},
+ {"SetResourceSize", (PyCFunction)ResObj_SetResourceSize, 1,
+ "(long newSize) -> None"},
+ {"GetNextFOND", (PyCFunction)ResObj_GetNextFOND, 1,
+ "() -> (Handle _rv)"},
+ {"as_Control", (PyCFunction)ResObj_as_Control, 1,
+ "Return this resource/handle as a Control"},
+ {"as_Menu", (PyCFunction)ResObj_as_Menu, 1,
+ "Return this resource/handle as a Menu"},
+ {"LoadResource", (PyCFunction)ResObj_LoadResource, 1,
+ "() -> None"},
+ {"AutoDispose", (PyCFunction)ResObj_AutoDispose, 1,
+ "(int)->int. Automatically DisposeHandle the object on Python object cleanup"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain ResObj_chain = { ResObj_methods, NULL };
+
+static PyObject *ResObj_getattr(ResourceObject *self, char *name)
+{
+
+ if (strcmp(name, "size") == 0)
+ return PyInt_FromLong(GetHandleSize(self->ob_itself));
+ if (strcmp(name, "data") == 0) {
+ PyObject *res;
+ char state;
+ state = HGetState(self->ob_itself);
+ HLock(self->ob_itself);
+ res = PyString_FromStringAndSize(
+ *self->ob_itself,
+ GetHandleSize(self->ob_itself));
+ HUnlock(self->ob_itself);
+ HSetState(self->ob_itself, state);
+ return res;
+ }
+ if (strcmp(name, "__members__") == 0)
+ return Py_BuildValue("[ss]", "data", "size");
+
+ return Py_FindMethodInChain(&ResObj_chain, (PyObject *)self, name);
+}
+
+static int
+ResObj_setattr(ResourceObject *self, char *name, PyObject *value)
+{
+ char *data;
+ long size;
+
+ if (strcmp(name, "data") != 0 || value == NULL )
+ return -1;
+ if ( !PyString_Check(value) )
+ return -1;
+ size = PyString_Size(value);
+ data = PyString_AsString(value);
+ /* XXXX Do I need the GetState/SetState calls? */
+ SetHandleSize(self->ob_itself, size);
+ if ( MemError())
+ return -1;
+ HLock(self->ob_itself);
+ memcpy((char *)*self->ob_itself, data, size);
+ HUnlock(self->ob_itself);
+ /* XXXX Should I do the Changed call immedeately? */
+ return 0;
+}
+
+
+#define ResObj_compare NULL
+
+#define ResObj_repr NULL
+
+#define ResObj_hash NULL
+
+PyTypeObject Resource_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "Resource", /*tp_name*/
+ sizeof(ResourceObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) ResObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) ResObj_getattr, /*tp_getattr*/
+ (setattrfunc) ResObj_setattr, /*tp_setattr*/
+ (cmpfunc) ResObj_compare, /*tp_compare*/
+ (reprfunc) ResObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) ResObj_hash, /*tp_hash*/
+};
+
+/* -------------------- End object type Resource -------------------- */
+
+
+#if TARGET_API_MAC_OS8
+
+static PyObject *Res_InitResources(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = InitResources();
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_OS8
+
+static PyObject *Res_RsrcZoneInit(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ RsrcZoneInit();
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Res_CloseResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short refNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &refNum))
+ return NULL;
+ CloseResFile(refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_ResError(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = ResError();
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_CurResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CurResFile();
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+#if TARGET_API_MAC_OS8
+
+static PyObject *Res_CreateResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Str255 fileName;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, fileName))
+ return NULL;
+ CreateResFile(fileName);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_OS8
+
+static PyObject *Res_OpenResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ Str255 fileName;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, fileName))
+ return NULL;
+ _rv = OpenResFile(fileName);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *Res_UseResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short refNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &refNum))
+ return NULL;
+ UseResFile(refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_CountTypes(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CountTypes();
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_Count1Types(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = Count1Types();
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_GetIndType(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ResType theType;
+ short index;
+ if (!PyArg_ParseTuple(_args, "h",
+ &index))
+ return NULL;
+ GetIndType(&theType,
+ index);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ PyMac_BuildOSType, theType);
+ return _res;
+}
+
+static PyObject *Res_Get1IndType(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ResType theType;
+ short index;
+ if (!PyArg_ParseTuple(_args, "h",
+ &index))
+ return NULL;
+ Get1IndType(&theType,
+ index);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ PyMac_BuildOSType, theType);
+ return _res;
+}
+
+static PyObject *Res_SetResLoad(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean load;
+ if (!PyArg_ParseTuple(_args, "b",
+ &load))
+ return NULL;
+ SetResLoad(load);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_CountResources(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ ResType theType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theType))
+ return NULL;
+ _rv = CountResources(theType);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_Count1Resources(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ ResType theType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theType))
+ return NULL;
+ _rv = Count1Resources(theType);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_GetIndResource(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ResType theType;
+ short index;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetOSType, &theType,
+ &index))
+ return NULL;
+ _rv = GetIndResource(theType,
+ index);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Res_Get1IndResource(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ResType theType;
+ short index;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetOSType, &theType,
+ &index))
+ return NULL;
+ _rv = Get1IndResource(theType,
+ index);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Res_GetResource(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ResType theType;
+ short theID;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetOSType, &theType,
+ &theID))
+ return NULL;
+ _rv = GetResource(theType,
+ theID);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Res_Get1Resource(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ResType theType;
+ short theID;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetOSType, &theType,
+ &theID))
+ return NULL;
+ _rv = Get1Resource(theType,
+ theID);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Res_GetNamedResource(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ResType theType;
+ Str255 name;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &theType,
+ PyMac_GetStr255, name))
+ return NULL;
+ _rv = GetNamedResource(theType,
+ name);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Res_Get1NamedResource(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ResType theType;
+ Str255 name;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &theType,
+ PyMac_GetStr255, name))
+ return NULL;
+ _rv = Get1NamedResource(theType,
+ name);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Res_UniqueID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ ResType theType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theType))
+ return NULL;
+ _rv = UniqueID(theType);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_Unique1ID(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ ResType theType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theType))
+ return NULL;
+ _rv = Unique1ID(theType);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_UpdateResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short refNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &refNum))
+ return NULL;
+ UpdateResFile(refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_SetResPurge(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean install;
+ if (!PyArg_ParseTuple(_args, "b",
+ &install))
+ return NULL;
+ SetResPurge(install);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_GetResFileAttrs(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ short refNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &refNum))
+ return NULL;
+ _rv = GetResFileAttrs(refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_SetResFileAttrs(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short refNum;
+ short attrs;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &refNum,
+ &attrs))
+ return NULL;
+ SetResFileAttrs(refNum,
+ attrs);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_OpenRFPerm(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ Str255 fileName;
+ short vRefNum;
+ SignedByte permission;
+ if (!PyArg_ParseTuple(_args, "O&hb",
+ PyMac_GetStr255, fileName,
+ &vRefNum,
+ &permission))
+ return NULL;
+ _rv = OpenRFPerm(fileName,
+ vRefNum,
+ permission);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+#if TARGET_API_MAC_OS8
+
+static PyObject *Res_RGetResource(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ResType theType;
+ short theID;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetOSType, &theType,
+ &theID))
+ return NULL;
+ _rv = RGetResource(theType,
+ theID);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+#endif
+
+static PyObject *Res_HOpenResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ short vRefNum;
+ long dirID;
+ Str255 fileName;
+ SignedByte permission;
+ if (!PyArg_ParseTuple(_args, "hlO&b",
+ &vRefNum,
+ &dirID,
+ PyMac_GetStr255, fileName,
+ &permission))
+ return NULL;
+ _rv = HOpenResFile(vRefNum,
+ dirID,
+ fileName,
+ permission);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_HCreateResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short vRefNum;
+ long dirID;
+ Str255 fileName;
+ if (!PyArg_ParseTuple(_args, "hlO&",
+ &vRefNum,
+ &dirID,
+ PyMac_GetStr255, fileName))
+ return NULL;
+ HCreateResFile(vRefNum,
+ dirID,
+ fileName);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_FSpOpenResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ FSSpec spec;
+ SignedByte permission;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ PyMac_GetFSSpec, &spec,
+ &permission))
+ return NULL;
+ _rv = FSpOpenResFile(&spec,
+ permission);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_FSpCreateResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ FSSpec spec;
+ OSType creator;
+ OSType fileType;
+ ScriptCode scriptTag;
+ if (!PyArg_ParseTuple(_args, "O&O&O&h",
+ PyMac_GetFSSpec, &spec,
+ PyMac_GetOSType, &creator,
+ PyMac_GetOSType, &fileType,
+ &scriptTag))
+ return NULL;
+ FSpCreateResFile(&spec,
+ creator,
+ fileType,
+ scriptTag);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Res_InsertResourceFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ SInt16 refNum;
+ RsrcChainLocation where;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &refNum,
+ &where))
+ return NULL;
+ _rv = InsertResourceFile(refNum,
+ where);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Res_DetachResourceFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ SInt16 refNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &refNum))
+ return NULL;
+ _rv = DetachResourceFile(refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Res_FSpResourceFileAlreadyOpen(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ FSSpec resourceFile;
+ Boolean inChain;
+ SInt16 refNum;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFSSpec, &resourceFile))
+ return NULL;
+ _rv = FSpResourceFileAlreadyOpen(&resourceFile,
+ &inChain,
+ &refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("bbh",
+ _rv,
+ inChain,
+ refNum);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Res_FSpOpenOrphanResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ FSSpec spec;
+ SignedByte permission;
+ SInt16 refNum;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ PyMac_GetFSSpec, &spec,
+ &permission))
+ return NULL;
+ _rv = FSpOpenOrphanResFile(&spec,
+ permission,
+ &refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("hh",
+ _rv,
+ refNum);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Res_GetTopResourceFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ SInt16 refNum;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetTopResourceFile(&refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("hh",
+ _rv,
+ refNum);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Res_GetNextResourceFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ SInt16 curRefNum;
+ SInt16 nextRefNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &curRefNum))
+ return NULL;
+ _rv = GetNextResourceFile(curRefNum,
+ &nextRefNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("hh",
+ _rv,
+ nextRefNum);
+ return _res;
+}
+#endif
+
+static PyObject *Res_Resource(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ char *buf;
+ int len;
+ Handle h;
+
+ if (!PyArg_ParseTuple(_args, "s#", &buf, &len))
+ return NULL;
+ h = NewHandle(len);
+ if ( h == NULL ) {
+ PyErr_NoMemory();
+ return NULL;
+ }
+ HLock(h);
+ memcpy(*h, buf, len);
+ HUnlock(h);
+ return ResObj_New(h);
+
+}
+
+static PyObject *Res_Handle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ char *buf;
+ int len;
+ Handle h;
+ ResourceObject *rv;
+
+ if (!PyArg_ParseTuple(_args, "s#", &buf, &len))
+ return NULL;
+ h = NewHandle(len);
+ if ( h == NULL ) {
+ PyErr_NoMemory();
+ return NULL;
+ }
+ HLock(h);
+ memcpy(*h, buf, len);
+ HUnlock(h);
+ rv = (ResourceObject *)ResObj_New(h);
+ rv->ob_freeit = PyMac_AutoDisposeHandle;
+ return (PyObject *)rv;
+
+}
+
+static PyMethodDef Res_methods[] = {
+
+#if TARGET_API_MAC_OS8
+ {"InitResources", (PyCFunction)Res_InitResources, 1,
+ "() -> (short _rv)"},
+#endif
+
+#if TARGET_API_MAC_OS8
+ {"RsrcZoneInit", (PyCFunction)Res_RsrcZoneInit, 1,
+ "() -> None"},
+#endif
+ {"CloseResFile", (PyCFunction)Res_CloseResFile, 1,
+ "(short refNum) -> None"},
+ {"ResError", (PyCFunction)Res_ResError, 1,
+ "() -> (OSErr _rv)"},
+ {"CurResFile", (PyCFunction)Res_CurResFile, 1,
+ "() -> (short _rv)"},
+
+#if TARGET_API_MAC_OS8
+ {"CreateResFile", (PyCFunction)Res_CreateResFile, 1,
+ "(Str255 fileName) -> None"},
+#endif
+
+#if TARGET_API_MAC_OS8
+ {"OpenResFile", (PyCFunction)Res_OpenResFile, 1,
+ "(Str255 fileName) -> (short _rv)"},
+#endif
+ {"UseResFile", (PyCFunction)Res_UseResFile, 1,
+ "(short refNum) -> None"},
+ {"CountTypes", (PyCFunction)Res_CountTypes, 1,
+ "() -> (short _rv)"},
+ {"Count1Types", (PyCFunction)Res_Count1Types, 1,
+ "() -> (short _rv)"},
+ {"GetIndType", (PyCFunction)Res_GetIndType, 1,
+ "(short index) -> (ResType theType)"},
+ {"Get1IndType", (PyCFunction)Res_Get1IndType, 1,
+ "(short index) -> (ResType theType)"},
+ {"SetResLoad", (PyCFunction)Res_SetResLoad, 1,
+ "(Boolean load) -> None"},
+ {"CountResources", (PyCFunction)Res_CountResources, 1,
+ "(ResType theType) -> (short _rv)"},
+ {"Count1Resources", (PyCFunction)Res_Count1Resources, 1,
+ "(ResType theType) -> (short _rv)"},
+ {"GetIndResource", (PyCFunction)Res_GetIndResource, 1,
+ "(ResType theType, short index) -> (Handle _rv)"},
+ {"Get1IndResource", (PyCFunction)Res_Get1IndResource, 1,
+ "(ResType theType, short index) -> (Handle _rv)"},
+ {"GetResource", (PyCFunction)Res_GetResource, 1,
+ "(ResType theType, short theID) -> (Handle _rv)"},
+ {"Get1Resource", (PyCFunction)Res_Get1Resource, 1,
+ "(ResType theType, short theID) -> (Handle _rv)"},
+ {"GetNamedResource", (PyCFunction)Res_GetNamedResource, 1,
+ "(ResType theType, Str255 name) -> (Handle _rv)"},
+ {"Get1NamedResource", (PyCFunction)Res_Get1NamedResource, 1,
+ "(ResType theType, Str255 name) -> (Handle _rv)"},
+ {"UniqueID", (PyCFunction)Res_UniqueID, 1,
+ "(ResType theType) -> (short _rv)"},
+ {"Unique1ID", (PyCFunction)Res_Unique1ID, 1,
+ "(ResType theType) -> (short _rv)"},
+ {"UpdateResFile", (PyCFunction)Res_UpdateResFile, 1,
+ "(short refNum) -> None"},
+ {"SetResPurge", (PyCFunction)Res_SetResPurge, 1,
+ "(Boolean install) -> None"},
+ {"GetResFileAttrs", (PyCFunction)Res_GetResFileAttrs, 1,
+ "(short refNum) -> (short _rv)"},
+ {"SetResFileAttrs", (PyCFunction)Res_SetResFileAttrs, 1,
+ "(short refNum, short attrs) -> None"},
+ {"OpenRFPerm", (PyCFunction)Res_OpenRFPerm, 1,
+ "(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)"},
+
+#if TARGET_API_MAC_OS8
+ {"RGetResource", (PyCFunction)Res_RGetResource, 1,
+ "(ResType theType, short theID) -> (Handle _rv)"},
+#endif
+ {"HOpenResFile", (PyCFunction)Res_HOpenResFile, 1,
+ "(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)"},
+ {"HCreateResFile", (PyCFunction)Res_HCreateResFile, 1,
+ "(short vRefNum, long dirID, Str255 fileName) -> None"},
+ {"FSpOpenResFile", (PyCFunction)Res_FSpOpenResFile, 1,
+ "(FSSpec spec, SignedByte permission) -> (short _rv)"},
+ {"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1,
+ "(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"InsertResourceFile", (PyCFunction)Res_InsertResourceFile, 1,
+ "(SInt16 refNum, RsrcChainLocation where) -> (OSErr _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"DetachResourceFile", (PyCFunction)Res_DetachResourceFile, 1,
+ "(SInt16 refNum) -> (OSErr _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"FSpResourceFileAlreadyOpen", (PyCFunction)Res_FSpResourceFileAlreadyOpen, 1,
+ "(FSSpec resourceFile) -> (Boolean _rv, Boolean inChain, SInt16 refNum)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"FSpOpenOrphanResFile", (PyCFunction)Res_FSpOpenOrphanResFile, 1,
+ "(FSSpec spec, SignedByte permission) -> (OSErr _rv, SInt16 refNum)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetTopResourceFile", (PyCFunction)Res_GetTopResourceFile, 1,
+ "() -> (OSErr _rv, SInt16 refNum)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetNextResourceFile", (PyCFunction)Res_GetNextResourceFile, 1,
+ "(SInt16 curRefNum) -> (OSErr _rv, SInt16 nextRefNum)"},
+#endif
+ {"Resource", (PyCFunction)Res_Resource, 1,
+ "Convert a string to a resource object.\n\nThe created resource object is actually just a handle,\napply AddResource() to write it to a resource file.\nSee also the Handle() docstring.\n"},
+ {"Handle", (PyCFunction)Res_Handle, 1,
+ "Convert a string to a Handle object.\n\nResource() and Handle() are very similar, but objects created with Handle() are\nby default automatically DisposeHandle()d upon object cleanup. Use AutoDispose()\nto change this.\n"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+/* Alternative version of ResObj_New, which returns None for null argument */
+PyObject *OptResObj_New(Handle itself)
+{
+ if (itself == NULL) {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+ return ResObj_New(itself);
+}
+
+OptResObj_Convert(PyObject *v, Handle *p_itself)
+{
+ PyObject *tmp;
+
+ if ( v == Py_None ) {
+ *p_itself = NULL;
+ return 1;
+ }
+ if (ResObj_Check(v))
+ {
+ *p_itself = ((ResourceObject *)v)->ob_itself;
+ return 1;
+ }
+ /* If it isn't a resource yet see whether it is convertible */
+ if ( (tmp=PyObject_CallMethod(v, "as_Resource", "")) ) {
+ *p_itself = ((ResourceObject *)tmp)->ob_itself;
+ Py_DECREF(tmp);
+ return 1;
+ }
+ PyErr_Clear();
+ PyErr_SetString(PyExc_TypeError, "Resource required");
+ return 0;
+}
+
+
+void init_Res(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(Handle, ResObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Handle, ResObj_Convert);
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(Handle, OptResObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Handle, OptResObj_Convert);
+
+
+ m = Py_InitModule("_Res", Res_methods);
+ d = PyModule_GetDict(m);
+ Res_Error = PyMac_GetOSErrException();
+ if (Res_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Res_Error) != 0)
+ return;
+ Resource_Type.ob_type = &PyType_Type;
+ Py_INCREF(&Resource_Type);
+ if (PyDict_SetItemString(d, "ResourceType", (PyObject *)&Resource_Type) != 0)
+ Py_FatalError("can't initialize ResourceType");
+}
+
+/* ======================== End module _Res ========================= */
+
--- /dev/null
+
+/* ========================== Module Scrap ========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Scrap.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+/*
+** Generate ScrapInfo records
+*/
+static PyObject *
+SCRRec_New(itself)
+ ScrapStuff *itself;
+{
+
+ return Py_BuildValue("lO&hhO&", itself->scrapSize,
+ ResObj_New, itself->scrapHandle, itself->scrapCount, itself->scrapState,
+ PyMac_BuildStr255, itself->scrapName);
+}
+#endif
+
+static PyObject *Scrap_Error;
+
+static PyObject *Scrap_LoadScrap(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = LoadScrap();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Scrap_UnloadScrap(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = UnloadScrap();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Scrap_InfoScrap(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ScrapStuffPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = InfoScrap();
+ _res = Py_BuildValue("O&",
+ SCRRec_New, _rv);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Scrap_GetScrap(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ Handle destination;
+ ScrapFlavorType flavorType;
+ SInt32 offset;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &destination,
+ PyMac_GetOSType, &flavorType))
+ return NULL;
+ _rv = GetScrap(destination,
+ flavorType,
+ &offset);
+ _res = Py_BuildValue("ll",
+ _rv,
+ offset);
+ return _res;
+}
+#endif
+
+
+static PyObject *Scrap_ZeroScrap(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+#if TARGET_API_MAC_CARBON
+ {
+ ScrapRef scrap;
+
+ _err = ClearCurrentScrap();
+ if (_err != noErr) return PyMac_Error(_err);
+ _err = GetCurrentScrap(&scrap);
+ }
+#else
+ _err = ZeroScrap();
+#endif
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Scrap_PutScrap(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ SInt32 sourceBufferByteCount;
+ ScrapFlavorType flavorType;
+ char *sourceBuffer__in__;
+ int sourceBuffer__len__;
+ int sourceBuffer__in_len__;
+#if TARGET_API_MAC_CARBON
+ ScrapRef scrap;
+#endif
+
+ if (!PyArg_ParseTuple(_args, "O&s#",
+ PyMac_GetOSType, &flavorType,
+ &sourceBuffer__in__, &sourceBuffer__in_len__))
+ return NULL;
+ sourceBufferByteCount = sourceBuffer__in_len__;
+ sourceBuffer__len__ = sourceBuffer__in_len__;
+#if TARGET_API_MAC_CARBON
+ _err = GetCurrentScrap(&scrap);
+ if (_err != noErr) return PyMac_Error(_err);
+ _err = PutScrapFlavor(scrap, flavorType, 0, sourceBufferByteCount, sourceBuffer__in__);
+#else
+ _err = PutScrap(sourceBufferByteCount,
+ flavorType,
+ sourceBuffer__in__);
+#endif
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ sourceBuffer__error__: ;
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Scrap_ClearCurrentScrap(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = ClearCurrentScrap();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Scrap_CallInScrapPromises(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = CallInScrapPromises();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyMethodDef Scrap_methods[] = {
+ {"LoadScrap", (PyCFunction)Scrap_LoadScrap, 1,
+ "() -> None"},
+ {"UnloadScrap", (PyCFunction)Scrap_UnloadScrap, 1,
+ "() -> None"},
+
+#if !TARGET_API_MAC_CARBON
+ {"InfoScrap", (PyCFunction)Scrap_InfoScrap, 1,
+ "() -> (ScrapStuffPtr _rv)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"GetScrap", (PyCFunction)Scrap_GetScrap, 1,
+ "(Handle destination, ScrapFlavorType flavorType) -> (long _rv, SInt32 offset)"},
+#endif
+
+ {"ZeroScrap", (PyCFunction)Scrap_ZeroScrap, 1,
+ "() -> None"},
+
+ {"PutScrap", (PyCFunction)Scrap_PutScrap, 1,
+ "(ScrapFlavorType flavorType, Buffer sourceBuffer) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"ClearCurrentScrap", (PyCFunction)Scrap_ClearCurrentScrap, 1,
+ "() -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"CallInScrapPromises", (PyCFunction)Scrap_CallInScrapPromises, 1,
+ "() -> None"},
+#endif
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_Scrap()
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+ m = Py_InitModule("_Scrap", Scrap_methods);
+ d = PyModule_GetDict(m);
+ Scrap_Error = PyMac_GetOSErrException();
+ if (Scrap_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Scrap_Error) != 0)
+ return;
+}
+
+/* ======================== End module Scrap ======================== */
+
--- /dev/null
+/***********************************************************
+Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
+The Netherlands.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI or Corporation for National Research Initiatives or
+CNRI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+While CWI is the initial source for this software, a modified version
+is made available by the Corporation for National Research Initiatives
+(CNRI) at the Internet address ftp://ftp.python.org.
+
+STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
+CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+#include "Python.h"
+#include "macglue.h"
+#include "pymactoolbox.h"
+#include <Sound.h>
+
+#pragma options align=mac68k
+struct SampleRateAvailable_arg {
+ short numrates;
+ Handle rates;
+};
+
+struct SampleSizeAvailable_arg {
+ short numsizes;
+ Handle sizes;
+};
+
+#pragma options align=reset
+
+static PyObject *ErrorObject;
+
+
+/* Convert Python object to unsigned Fixed */
+static int
+PyMac_GetUFixed(PyObject *v, Fixed *f)
+{
+ double d;
+ unsigned long uns;
+
+ if( !PyArg_Parse(v, "d", &d))
+ return 0;
+ uns = (unsigned long)(d * 0x10000);
+ *f = (Fixed)uns;
+ return 1;
+}
+
+/* Convert a Point to a Python object */
+static PyObject *
+PyMac_BuildUFixed(Fixed f)
+{
+ double d;
+ unsigned long funs;
+
+ funs = (unsigned long)f;
+
+ d = funs;
+ d = d / 0x10000;
+ return Py_BuildValue("d", d);
+}
+
+
+/* ----------------------------------------------------- */
+
+static char sndih_getChannelAvailable__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getChannelAvailable(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ short nchannel;
+ OSErr err;
+
+ if (!PyArg_ParseTuple(args, "l", &inRefNum))
+ return NULL;
+
+ if( (err=SPBGetDeviceInfo(inRefNum, siChannelAvailable, (Ptr)&nchannel)) != noErr )
+ return PyMac_Error(err);
+ return Py_BuildValue("h", nchannel);
+}
+
+static char sndih_getNumberChannels__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getNumberChannels(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ short nchannel;
+ OSErr err;
+
+ if (!PyArg_ParseTuple(args, "l", &inRefNum))
+ return NULL;
+
+ if( (err=SPBGetDeviceInfo(inRefNum, siNumberChannels, (Ptr)&nchannel)) != noErr )
+ return PyMac_Error(err);
+ return Py_BuildValue("h", nchannel);
+}
+
+static char sndih_setNumberChannels__doc__[] =
+""
+;
+
+static PyObject *
+sndih_setNumberChannels(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ short nchannel;
+ OSErr err;
+
+ if (!PyArg_ParseTuple(args, "lh", &inRefNum, &nchannel))
+ return NULL;
+
+ if( (err=SPBSetDeviceInfo(inRefNum, siNumberChannels, (Ptr)&nchannel)) != noErr )
+ return PyMac_Error(err);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static char sndih_getContinuous__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getContinuous(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ short onoff;
+ OSErr err;
+
+ if (!PyArg_ParseTuple(args, "l", &inRefNum))
+ return NULL;
+
+ if( (err=SPBGetDeviceInfo(inRefNum, siContinuous, (Ptr)&onoff)) != noErr )
+ return PyMac_Error(err);
+ return Py_BuildValue("h", onoff);
+}
+
+static char sndih_setContinuous__doc__[] =
+""
+;
+
+static PyObject *
+sndih_setContinuous(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ short onoff;
+ OSErr err;
+
+ if (!PyArg_ParseTuple(args, "lh", &inRefNum, &onoff))
+ return NULL;
+
+ if( (err=SPBSetDeviceInfo(inRefNum, siContinuous, (Ptr)&onoff)) != noErr )
+ return PyMac_Error(err);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static char sndih_getInputSourceNames__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getInputSourceNames(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ Handle names;
+ OSErr err;
+
+ if (!PyArg_ParseTuple(args, "l", &inRefNum))
+ return NULL;
+
+ if( (err=SPBGetDeviceInfo(inRefNum, siInputSourceNames, (Ptr)&names)) != noErr )
+ return PyMac_Error(err);
+ return Py_BuildValue("O&", ResObj_New, names);
+}
+
+static char sndih_getInputSource__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getInputSource(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ short source;
+ OSErr err;
+
+ if (!PyArg_ParseTuple(args, "l", &inRefNum))
+ return NULL;
+
+ if( (err=SPBGetDeviceInfo(inRefNum, siInputSource, (Ptr)&source)) != noErr )
+ return PyMac_Error(err);
+ return Py_BuildValue("h", source);
+}
+
+static char sndih_setInputSource__doc__[] =
+""
+;
+
+static PyObject *
+sndih_setInputSource(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ short source;
+ OSErr err;
+
+ if (!PyArg_ParseTuple(args, "lh", &inRefNum, &source))
+ return NULL;
+
+ if( (err=SPBSetDeviceInfo(inRefNum, siInputSource, (Ptr)&source)) != noErr )
+ return PyMac_Error(err);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static char sndih_getPlayThruOnOff__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getPlayThruOnOff(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ short onoff;
+ OSErr err;
+
+ if (!PyArg_ParseTuple(args, "l", &inRefNum))
+ return NULL;
+
+ if( (err=SPBGetDeviceInfo(inRefNum, siPlayThruOnOff, (Ptr)&onoff)) != noErr )
+ return PyMac_Error(err);
+ return Py_BuildValue("h", onoff);
+}
+
+static char sndih_setPlayThruOnOff__doc__[] =
+""
+;
+
+static PyObject *
+sndih_setPlayThruOnOff(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ short onoff;
+ OSErr err;
+
+ if (!PyArg_ParseTuple(args, "lh", &inRefNum, &onoff))
+ return NULL;
+
+ if( (err=SPBSetDeviceInfo(inRefNum, siPlayThruOnOff, (Ptr)&onoff)) != noErr )
+ return PyMac_Error(err);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static char sndih_getSampleRate__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getSampleRate(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ Fixed sample_rate;
+ OSErr err;
+
+ if (!PyArg_ParseTuple(args, "l", &inRefNum))
+ return NULL;
+
+ if( (err=SPBGetDeviceInfo(inRefNum, siSampleRate, (Ptr)&sample_rate)) != noErr )
+ return PyMac_Error(err);
+ return Py_BuildValue("O&", PyMac_BuildUFixed, sample_rate);
+}
+
+static char sndih_setSampleRate__doc__[] =
+""
+;
+
+static PyObject *
+sndih_setSampleRate(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ Fixed sample_rate;
+ OSErr err;
+
+ if (!PyArg_ParseTuple(args, "lO&", &inRefNum, PyMac_GetUFixed, &sample_rate))
+ return NULL;
+
+ if( (err=SPBSetDeviceInfo(inRefNum, siSampleRate, (Ptr)&sample_rate)) != noErr )
+ return PyMac_Error(err);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static char sndih_getSampleSize__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getSampleSize(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ short bits;
+ OSErr err;
+
+ if (!PyArg_ParseTuple(args, "l", &inRefNum))
+ return NULL;
+
+ if( (err=SPBGetDeviceInfo(inRefNum, siSampleSize, (Ptr)&bits)) != noErr )
+ return PyMac_Error(err);
+ return Py_BuildValue("h", bits);
+}
+
+static char sndih_setSampleSize__doc__[] =
+""
+;
+
+static PyObject *
+sndih_setSampleSize(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ short size;
+ OSErr err;
+
+ if (!PyArg_ParseTuple(args, "lh", &inRefNum, &size))
+ return NULL;
+
+ if( (err=SPBSetDeviceInfo(inRefNum, siSampleSize, (Ptr)&size)) != noErr )
+ return PyMac_Error(err);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static char sndih_getSampleSizeAvailable__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getSampleSizeAvailable(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ struct SampleSizeAvailable_arg arg;
+ OSErr err;
+ PyObject *rsizes;
+ short *fsizes;
+ int i;
+
+ arg.sizes = NULL;
+ rsizes = NULL;
+ if (!PyArg_ParseTuple(args, "l", &inRefNum))
+ return NULL;
+
+ if( (err=SPBGetDeviceInfo(inRefNum, siSampleSizeAvailable, (Ptr)&arg)) != noErr ) {
+ return PyMac_Error(err);
+ }
+ fsizes = (short *)*(arg.sizes);
+ /* Handle contains a list of rates */
+ if( (rsizes = PyTuple_New(arg.numsizes)) == NULL)
+ return NULL;
+ for( i=0; i<arg.numsizes; i++ )
+ PyTuple_SetItem(rsizes, i, PyInt_FromLong((long)fsizes[i]));
+ return rsizes;
+}
+
+static char sndih_getSampleRateAvailable__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getSampleRateAvailable(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ long inRefNum;
+ struct SampleRateAvailable_arg arg;
+ OSErr err;
+ PyObject *rrates, *obj;
+ Fixed *frates;
+ int i;
+
+ arg.rates = NULL;
+ rrates = NULL;
+ if (!PyArg_ParseTuple(args, "l", &inRefNum))
+ return NULL;
+
+ if( (err=SPBGetDeviceInfo(inRefNum, siSampleRateAvailable, (Ptr)&arg)) != noErr ) {
+ return PyMac_Error(err);
+ }
+ frates = (Fixed *)*(arg.rates);
+ if( arg.numrates == 0 ) {
+ /* The handle contains upper and lowerbound */
+ rrates = Py_BuildValue("O&O&", frates[0], frates[1]);
+ if (rrates == NULL) return NULL;
+ } else {
+ /* Handle contains a list of rates */
+ if( (rrates = PyTuple_New(arg.numrates)) == NULL)
+ return NULL;
+ for( i=0; i<arg.numrates; i++ ) {
+ if( (obj = Py_BuildValue("O&", PyMac_BuildUFixed, frates[i]))==NULL)
+ goto out;
+ PyTuple_SetItem(rrates, i, obj);
+ }
+ }
+ return Py_BuildValue("hO", arg.numrates, rrates);
+out:
+ Py_XDECREF(rrates);
+ return NULL;
+}
+
+/* List of methods defined in the module */
+
+static struct PyMethodDef sndih_methods[] = {
+ {"getChannelAvailable", (PyCFunction)sndih_getChannelAvailable, METH_VARARGS, sndih_getChannelAvailable__doc__},
+ {"getNumberChannels", (PyCFunction)sndih_getNumberChannels, METH_VARARGS, sndih_getNumberChannels__doc__},
+ {"setNumberChannels", (PyCFunction)sndih_setNumberChannels, METH_VARARGS, sndih_setNumberChannels__doc__},
+ {"getContinuous", (PyCFunction)sndih_getContinuous, METH_VARARGS, sndih_getContinuous__doc__},
+ {"setContinuous", (PyCFunction)sndih_setContinuous, METH_VARARGS, sndih_setContinuous__doc__},
+ {"getInputSourceNames", (PyCFunction)sndih_getInputSourceNames, METH_VARARGS, sndih_getInputSourceNames__doc__},
+ {"getInputSource", (PyCFunction)sndih_getInputSource, METH_VARARGS, sndih_getInputSource__doc__},
+ {"setInputSource", (PyCFunction)sndih_setInputSource, METH_VARARGS, sndih_setInputSource__doc__},
+ {"getPlayThruOnOff", (PyCFunction)sndih_getPlayThruOnOff, METH_VARARGS, sndih_getPlayThruOnOff__doc__},
+ {"setPlayThruOnOff", (PyCFunction)sndih_setPlayThruOnOff, METH_VARARGS, sndih_setPlayThruOnOff__doc__},
+ {"getSampleRate", (PyCFunction)sndih_getSampleRate, METH_VARARGS, sndih_getSampleRate__doc__},
+ {"setSampleRate", (PyCFunction)sndih_setSampleRate, METH_VARARGS, sndih_setSampleRate__doc__},
+ {"getSampleSize", (PyCFunction)sndih_getSampleSize, METH_VARARGS, sndih_getSampleSize__doc__},
+ {"setSampleSize", (PyCFunction)sndih_setSampleSize, METH_VARARGS, sndih_setSampleSize__doc__},
+ {"getSampleSizeAvailable", (PyCFunction)sndih_getSampleSizeAvailable, METH_VARARGS, sndih_getSampleSizeAvailable__doc__},
+ {"getSampleRateAvailable", (PyCFunction)sndih_getSampleRateAvailable, METH_VARARGS, sndih_getSampleRateAvailable__doc__},
+
+ {NULL, (PyCFunction)NULL, 0, NULL} /* sentinel */
+};
+
+
+/* Initialization function for the module (*must* be called initSndihooks) */
+
+static char Sndihooks_module_documentation[] =
+""
+;
+
+void
+init_Sndihooks()
+{
+ PyObject *m, *d;
+
+ /* Create the module and add the functions */
+ m = Py_InitModule4("_Sndihooks", sndih_methods,
+ Sndihooks_module_documentation,
+ (PyObject*)NULL,PYTHON_API_VERSION);
+
+ /* Add some symbolic constants to the module */
+ d = PyModule_GetDict(m);
+ ErrorObject = PyString_FromString("Sndihooks.error");
+ PyDict_SetItemString(d, "error", ErrorObject);
+
+ /* XXXX Add constants here */
+
+ /* Check for errors */
+ if (PyErr_Occurred())
+ Py_FatalError("can't initialize module Sndihooks");
+}
+
--- /dev/null
+
+/* ========================== Module _Snd =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Sound.h>
+#include <OSUtils.h> /* for Set(Current)A5 */
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+
+/* Create a SndCommand object (an (int, int, int) tuple) */
+static PyObject *
+SndCmd_New(SndCommand *pc)
+{
+ return Py_BuildValue("hhl", pc->cmd, pc->param1, pc->param2);
+}
+
+/* Convert a SndCommand argument */
+static int
+SndCmd_Convert(PyObject *v, SndCommand *pc)
+{
+ int len;
+ pc->param1 = 0;
+ pc->param2 = 0;
+ if (PyTuple_Check(v)) {
+ if (PyArg_ParseTuple(v, "h|hl", &pc->cmd, &pc->param1, &pc->param2))
+ return 1;
+ PyErr_Clear();
+ return PyArg_ParseTuple(v, "Hhs#", &pc->cmd, &pc->param1, &pc->param2, &len);
+ }
+ return PyArg_Parse(v, "H", &pc->cmd);
+}
+
+static pascal void SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd); /* Forward */
+static pascal void SPB_completion(SPBPtr my_spb); /* Forward */
+#if !TARGET_API_MAC_CARBON
+static pascal void SPB_interrupt(SPBPtr my_spb); /* Forward */
+#endif
+
+static PyObject *Snd_Error;
+
+/* --------------------- Object type SndChannel --------------------- */
+
+staticforward PyTypeObject SndChannel_Type;
+
+#define SndCh_Check(x) ((x)->ob_type == &SndChannel_Type)
+
+typedef struct SndChannelObject {
+ PyObject_HEAD
+ SndChannelPtr ob_itself;
+ /* Members used to implement callbacks: */
+ PyObject *ob_callback;
+ long ob_A5;
+ SndCommand ob_cmd;
+} SndChannelObject;
+
+static PyObject *SndCh_New(SndChannelPtr itself)
+{
+ SndChannelObject *it;
+ it = PyObject_NEW(SndChannelObject, &SndChannel_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_callback = NULL;
+ it->ob_A5 = SetCurrentA5();
+ return (PyObject *)it;
+}
+static SndCh_Convert(PyObject *v, SndChannelPtr *p_itself)
+{
+ if (!SndCh_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "SndChannel required");
+ return 0;
+ }
+ *p_itself = ((SndChannelObject *)v)->ob_itself;
+ return 1;
+}
+
+static void SndCh_dealloc(SndChannelObject *self)
+{
+ SndDisposeChannel(self->ob_itself, 1);
+ Py_XDECREF(self->ob_callback);
+ PyMem_DEL(self);
+}
+
+static PyObject *SndCh_SndDoCommand(SndChannelObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SndCommand cmd;
+ Boolean noWait;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ SndCmd_Convert, &cmd,
+ &noWait))
+ return NULL;
+ _err = SndDoCommand(_self->ob_itself,
+ &cmd,
+ noWait);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *SndCh_SndDoImmediate(SndChannelObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SndCommand cmd;
+ if (!PyArg_ParseTuple(_args, "O&",
+ SndCmd_Convert, &cmd))
+ return NULL;
+ _err = SndDoImmediate(_self->ob_itself,
+ &cmd);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *SndCh_SndPlay(SndChannelObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SndListHandle sndHandle;
+ Boolean async;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ ResObj_Convert, &sndHandle,
+ &async))
+ return NULL;
+ _err = SndPlay(_self->ob_itself,
+ sndHandle,
+ async);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *SndCh_SndStartFilePlay(SndChannelObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short fRefNum;
+ short resNum;
+ long bufferSize;
+ Boolean async;
+ if (!PyArg_ParseTuple(_args, "hhlb",
+ &fRefNum,
+ &resNum,
+ &bufferSize,
+ &async))
+ return NULL;
+ _err = SndStartFilePlay(_self->ob_itself,
+ fRefNum,
+ resNum,
+ bufferSize,
+ 0,
+ 0,
+ 0,
+ async);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *SndCh_SndPauseFilePlay(SndChannelObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = SndPauseFilePlay(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *SndCh_SndStopFilePlay(SndChannelObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Boolean quietNow;
+ if (!PyArg_ParseTuple(_args, "b",
+ &quietNow))
+ return NULL;
+ _err = SndStopFilePlay(_self->ob_itself,
+ quietNow);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *SndCh_SndChannelStatus(SndChannelObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short theLength;
+ SCStatus theStatus__out__;
+ if (!PyArg_ParseTuple(_args, "h",
+ &theLength))
+ return NULL;
+ _err = SndChannelStatus(_self->ob_itself,
+ theLength,
+ &theStatus__out__);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("s#",
+ (char *)&theStatus__out__, (int)sizeof(SCStatus));
+ theStatus__error__: ;
+ return _res;
+}
+
+static PyObject *SndCh_SndGetInfo(SndChannelObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType selector;
+ void * infoPtr;
+ if (!PyArg_ParseTuple(_args, "O&w",
+ PyMac_GetOSType, &selector,
+ &infoPtr))
+ return NULL;
+ _err = SndGetInfo(_self->ob_itself,
+ selector,
+ infoPtr);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *SndCh_SndSetInfo(SndChannelObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType selector;
+ void * infoPtr;
+ if (!PyArg_ParseTuple(_args, "O&w",
+ PyMac_GetOSType, &selector,
+ &infoPtr))
+ return NULL;
+ _err = SndSetInfo(_self->ob_itself,
+ selector,
+ infoPtr);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef SndCh_methods[] = {
+ {"SndDoCommand", (PyCFunction)SndCh_SndDoCommand, 1,
+ "(SndCommand cmd, Boolean noWait) -> None"},
+ {"SndDoImmediate", (PyCFunction)SndCh_SndDoImmediate, 1,
+ "(SndCommand cmd) -> None"},
+ {"SndPlay", (PyCFunction)SndCh_SndPlay, 1,
+ "(SndListHandle sndHandle, Boolean async) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+ {"SndStartFilePlay", (PyCFunction)SndCh_SndStartFilePlay, 1,
+ "(short fRefNum, short resNum, long bufferSize, Boolean async) -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"SndPauseFilePlay", (PyCFunction)SndCh_SndPauseFilePlay, 1,
+ "() -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"SndStopFilePlay", (PyCFunction)SndCh_SndStopFilePlay, 1,
+ "(Boolean quietNow) -> None"},
+#endif
+ {"SndChannelStatus", (PyCFunction)SndCh_SndChannelStatus, 1,
+ "(short theLength) -> (SCStatus theStatus)"},
+ {"SndGetInfo", (PyCFunction)SndCh_SndGetInfo, 1,
+ "(OSType selector, void * infoPtr) -> None"},
+ {"SndSetInfo", (PyCFunction)SndCh_SndSetInfo, 1,
+ "(OSType selector, void * infoPtr) -> None"},
+ {NULL, NULL, 0}
+};
+
+static PyMethodChain SndCh_chain = { SndCh_methods, NULL };
+
+static PyObject *SndCh_getattr(SndChannelObject *self, char *name)
+{
+ return Py_FindMethodInChain(&SndCh_chain, (PyObject *)self, name);
+}
+
+#define SndCh_setattr NULL
+
+#define SndCh_compare NULL
+
+#define SndCh_repr NULL
+
+#define SndCh_hash NULL
+
+staticforward PyTypeObject SndChannel_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "SndChannel", /*tp_name*/
+ sizeof(SndChannelObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) SndCh_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) SndCh_getattr, /*tp_getattr*/
+ (setattrfunc) SndCh_setattr, /*tp_setattr*/
+ (cmpfunc) SndCh_compare, /*tp_compare*/
+ (reprfunc) SndCh_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) SndCh_hash, /*tp_hash*/
+};
+
+/* ------------------- End object type SndChannel ------------------- */
+
+
+/* ------------------------ Object type SPB ------------------------- */
+
+staticforward PyTypeObject SPB_Type;
+
+#define SPBObj_Check(x) ((x)->ob_type == &SPB_Type)
+
+typedef struct SPBObject {
+ PyObject_HEAD
+ /* Members used to implement callbacks: */
+ PyObject *ob_completion;
+ PyObject *ob_interrupt;
+ PyObject *ob_thiscallback;
+ long ob_A5;
+ SPB ob_spb;
+} SPBObject;
+
+static PyObject *SPBObj_New(void)
+{
+ SPBObject *it;
+ it = PyObject_NEW(SPBObject, &SPB_Type);
+ if (it == NULL) return NULL;
+ it->ob_completion = NULL;
+ it->ob_interrupt = NULL;
+ it->ob_thiscallback = NULL;
+ it->ob_A5 = SetCurrentA5();
+ memset((char *)&it->ob_spb, 0, sizeof(it->ob_spb));
+ it->ob_spb.userLong = (long)it;
+ return (PyObject *)it;
+}
+static SPBObj_Convert(PyObject *v, SPBPtr *p_itself)
+{
+ if (!SPBObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "SPB required");
+ return 0;
+ }
+ *p_itself = &((SPBObject *)v)->ob_spb;
+ return 1;
+}
+
+static void SPBObj_dealloc(SPBObject *self)
+{
+ /* Cleanup of self->ob_itself goes here */
+ self->ob_spb.userLong = 0;
+ self->ob_thiscallback = 0;
+ Py_XDECREF(self->ob_completion);
+ Py_XDECREF(self->ob_interrupt);
+ PyMem_DEL(self);
+}
+
+static PyMethodDef SPBObj_methods[] = {
+ {NULL, NULL, 0}
+};
+
+static PyMethodChain SPBObj_chain = { SPBObj_methods, NULL };
+
+static PyObject *SPBObj_getattr(SPBObject *self, char *name)
+{
+
+ if (strcmp(name, "inRefNum") == 0)
+ return Py_BuildValue("l", self->ob_spb.inRefNum);
+ else if (strcmp(name, "count") == 0)
+ return Py_BuildValue("l", self->ob_spb.count);
+ else if (strcmp(name, "milliseconds") == 0)
+ return Py_BuildValue("l", self->ob_spb.milliseconds);
+ else if (strcmp(name, "error") == 0)
+ return Py_BuildValue("h", self->ob_spb.error);
+ return Py_FindMethodInChain(&SPBObj_chain, (PyObject *)self, name);
+}
+
+static int SPBObj_setattr(SPBObject *self, char *name, PyObject *value)
+{
+
+ int rv = 0;
+
+ if (strcmp(name, "inRefNum") == 0)
+ rv = PyArg_Parse(value, "l", &self->ob_spb.inRefNum);
+ else if (strcmp(name, "count") == 0)
+ rv = PyArg_Parse(value, "l", &self->ob_spb.count);
+ else if (strcmp(name, "milliseconds") == 0)
+ rv = PyArg_Parse(value, "l", &self->ob_spb.milliseconds);
+ else if (strcmp(name, "buffer") == 0)
+ rv = PyArg_Parse(value, "w#", &self->ob_spb.bufferPtr, &self->ob_spb.bufferLength);
+ else if (strcmp(name, "completionRoutine") == 0) {
+ self->ob_spb.completionRoutine = NewSICompletionUPP(SPB_completion);
+ self->ob_completion = value;
+ Py_INCREF(value);
+ rv = 1;
+#if !TARGET_API_MAC_CARBON
+ } else if (strcmp(name, "interruptRoutine") == 0) {
+ self->ob_spb.completionRoutine = NewSIInterruptUPP(SPB_interrupt);
+ self->ob_interrupt = value;
+ Py_INCREF(value);
+ rv = 1;
+#endif
+ }
+ if ( rv ) return 0;
+ else return -1;
+}
+
+#define SPBObj_compare NULL
+
+#define SPBObj_repr NULL
+
+#define SPBObj_hash NULL
+
+staticforward PyTypeObject SPB_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "SPB", /*tp_name*/
+ sizeof(SPBObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) SPBObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) SPBObj_getattr, /*tp_getattr*/
+ (setattrfunc) SPBObj_setattr, /*tp_setattr*/
+ (cmpfunc) SPBObj_compare, /*tp_compare*/
+ (reprfunc) SPBObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) SPBObj_hash, /*tp_hash*/
+};
+
+/* ---------------------- End object type SPB ----------------------- */
+
+
+static PyObject *Snd_SPB(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ return SPBObj_New();
+}
+
+static PyObject *Snd_SysBeep(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short duration;
+ if (!PyArg_ParseTuple(_args, "h",
+ &duration))
+ return NULL;
+ SysBeep(duration);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Snd_SndNewChannel(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SndChannelPtr chan = 0;
+ short synth;
+ long init;
+ PyObject* userRoutine;
+ if (!PyArg_ParseTuple(_args, "hlO",
+ &synth,
+ &init,
+ &userRoutine))
+ return NULL;
+ if (userRoutine != Py_None && !PyCallable_Check(userRoutine))
+ {
+ PyErr_SetString(PyExc_TypeError, "callback must be callable");
+ goto userRoutine__error__;
+ }
+ _err = SndNewChannel(&chan,
+ synth,
+ init,
+ NewSndCallBackUPP(SndCh_UserRoutine));
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ SndCh_New, chan);
+ if (_res != NULL && userRoutine != Py_None)
+ {
+ SndChannelObject *p = (SndChannelObject *)_res;
+ p->ob_itself->userInfo = (long)p;
+ Py_INCREF(userRoutine);
+ p->ob_callback = userRoutine;
+ }
+ userRoutine__error__: ;
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Snd_SndControl(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short id;
+ SndCommand cmd;
+ if (!PyArg_ParseTuple(_args, "h",
+ &id))
+ return NULL;
+ _err = SndControl(id,
+ &cmd);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ SndCmd_New, &cmd);
+ return _res;
+}
+#endif
+
+static PyObject *Snd_SndSoundManagerVersion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ NumVersion _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = SndSoundManagerVersion();
+ _res = Py_BuildValue("O&",
+ PyMac_BuildNumVersion, _rv);
+ return _res;
+}
+
+static PyObject *Snd_SndManagerStatus(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short theLength;
+ SMStatus theStatus__out__;
+ if (!PyArg_ParseTuple(_args, "h",
+ &theLength))
+ return NULL;
+ _err = SndManagerStatus(theLength,
+ &theStatus__out__);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("s#",
+ (char *)&theStatus__out__, (int)sizeof(SMStatus));
+ theStatus__error__: ;
+ return _res;
+}
+
+static PyObject *Snd_SndGetSysBeepState(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short sysBeepState;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ SndGetSysBeepState(&sysBeepState);
+ _res = Py_BuildValue("h",
+ sysBeepState);
+ return _res;
+}
+
+static PyObject *Snd_SndSetSysBeepState(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short sysBeepState;
+ if (!PyArg_ParseTuple(_args, "h",
+ &sysBeepState))
+ return NULL;
+ _err = SndSetSysBeepState(sysBeepState);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Snd_MACEVersion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ NumVersion _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MACEVersion();
+ _res = Py_BuildValue("O&",
+ PyMac_BuildNumVersion, _rv);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Snd_Comp3to1(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ char *buffer__in__;
+ char *buffer__out__;
+ long buffer__len__;
+ int buffer__in_len__;
+ StateBlock *state__in__;
+ StateBlock state__out__;
+ int state__in_len__;
+ unsigned long numChannels;
+ unsigned long whichChannel;
+ if (!PyArg_ParseTuple(_args, "s#s#ll",
+ &buffer__in__, &buffer__in_len__,
+ (char **)&state__in__, &state__in_len__,
+ &numChannels,
+ &whichChannel))
+ return NULL;
+ if ((buffer__out__ = malloc(buffer__in_len__)) == NULL)
+ {
+ PyErr_NoMemory();
+ goto buffer__error__;
+ }
+ buffer__len__ = buffer__in_len__;
+ if (state__in_len__ != sizeof(StateBlock))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(StateBlock)");
+ goto state__error__;
+ }
+ Comp3to1(buffer__in__, buffer__out__, (long)buffer__len__,
+ state__in__, &state__out__,
+ numChannels,
+ whichChannel);
+ _res = Py_BuildValue("s#s#",
+ buffer__out__, (int)buffer__len__,
+ (char *)&state__out__, (int)sizeof(StateBlock));
+ state__error__: ;
+ free(buffer__out__);
+ buffer__error__: ;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Snd_Exp1to3(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ char *buffer__in__;
+ char *buffer__out__;
+ long buffer__len__;
+ int buffer__in_len__;
+ StateBlock *state__in__;
+ StateBlock state__out__;
+ int state__in_len__;
+ unsigned long numChannels;
+ unsigned long whichChannel;
+ if (!PyArg_ParseTuple(_args, "s#s#ll",
+ &buffer__in__, &buffer__in_len__,
+ (char **)&state__in__, &state__in_len__,
+ &numChannels,
+ &whichChannel))
+ return NULL;
+ if ((buffer__out__ = malloc(buffer__in_len__)) == NULL)
+ {
+ PyErr_NoMemory();
+ goto buffer__error__;
+ }
+ buffer__len__ = buffer__in_len__;
+ if (state__in_len__ != sizeof(StateBlock))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(StateBlock)");
+ goto state__error__;
+ }
+ Exp1to3(buffer__in__, buffer__out__, (long)buffer__len__,
+ state__in__, &state__out__,
+ numChannels,
+ whichChannel);
+ _res = Py_BuildValue("s#s#",
+ buffer__out__, (int)buffer__len__,
+ (char *)&state__out__, (int)sizeof(StateBlock));
+ state__error__: ;
+ free(buffer__out__);
+ buffer__error__: ;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Snd_Comp6to1(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ char *buffer__in__;
+ char *buffer__out__;
+ long buffer__len__;
+ int buffer__in_len__;
+ StateBlock *state__in__;
+ StateBlock state__out__;
+ int state__in_len__;
+ unsigned long numChannels;
+ unsigned long whichChannel;
+ if (!PyArg_ParseTuple(_args, "s#s#ll",
+ &buffer__in__, &buffer__in_len__,
+ (char **)&state__in__, &state__in_len__,
+ &numChannels,
+ &whichChannel))
+ return NULL;
+ if ((buffer__out__ = malloc(buffer__in_len__)) == NULL)
+ {
+ PyErr_NoMemory();
+ goto buffer__error__;
+ }
+ buffer__len__ = buffer__in_len__;
+ if (state__in_len__ != sizeof(StateBlock))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(StateBlock)");
+ goto state__error__;
+ }
+ Comp6to1(buffer__in__, buffer__out__, (long)buffer__len__,
+ state__in__, &state__out__,
+ numChannels,
+ whichChannel);
+ _res = Py_BuildValue("s#s#",
+ buffer__out__, (int)buffer__len__,
+ (char *)&state__out__, (int)sizeof(StateBlock));
+ state__error__: ;
+ free(buffer__out__);
+ buffer__error__: ;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Snd_Exp1to6(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ char *buffer__in__;
+ char *buffer__out__;
+ long buffer__len__;
+ int buffer__in_len__;
+ StateBlock *state__in__;
+ StateBlock state__out__;
+ int state__in_len__;
+ unsigned long numChannels;
+ unsigned long whichChannel;
+ if (!PyArg_ParseTuple(_args, "s#s#ll",
+ &buffer__in__, &buffer__in_len__,
+ (char **)&state__in__, &state__in_len__,
+ &numChannels,
+ &whichChannel))
+ return NULL;
+ if ((buffer__out__ = malloc(buffer__in_len__)) == NULL)
+ {
+ PyErr_NoMemory();
+ goto buffer__error__;
+ }
+ buffer__len__ = buffer__in_len__;
+ if (state__in_len__ != sizeof(StateBlock))
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(StateBlock)");
+ goto state__error__;
+ }
+ Exp1to6(buffer__in__, buffer__out__, (long)buffer__len__,
+ state__in__, &state__out__,
+ numChannels,
+ whichChannel);
+ _res = Py_BuildValue("s#s#",
+ buffer__out__, (int)buffer__len__,
+ (char *)&state__out__, (int)sizeof(StateBlock));
+ state__error__: ;
+ free(buffer__out__);
+ buffer__error__: ;
+ return _res;
+}
+#endif
+
+static PyObject *Snd_GetSysBeepVolume(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long level;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetSysBeepVolume(&level);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ level);
+ return _res;
+}
+
+static PyObject *Snd_SetSysBeepVolume(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long level;
+ if (!PyArg_ParseTuple(_args, "l",
+ &level))
+ return NULL;
+ _err = SetSysBeepVolume(level);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Snd_GetDefaultOutputVolume(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long level;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetDefaultOutputVolume(&level);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ level);
+ return _res;
+}
+
+static PyObject *Snd_SetDefaultOutputVolume(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long level;
+ if (!PyArg_ParseTuple(_args, "l",
+ &level))
+ return NULL;
+ _err = SetDefaultOutputVolume(level);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Snd_GetSoundHeaderOffset(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SndListHandle sndHandle;
+ long offset;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &sndHandle))
+ return NULL;
+ _err = GetSoundHeaderOffset(sndHandle,
+ &offset);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ offset);
+ return _res;
+}
+
+static PyObject *Snd_GetCompressionInfo(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short compressionID;
+ OSType format;
+ short numChannels;
+ short sampleSize;
+ CompressionInfo cp__out__;
+ if (!PyArg_ParseTuple(_args, "hO&hh",
+ &compressionID,
+ PyMac_GetOSType, &format,
+ &numChannels,
+ &sampleSize))
+ return NULL;
+ _err = GetCompressionInfo(compressionID,
+ format,
+ numChannels,
+ sampleSize,
+ &cp__out__);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("s#",
+ (char *)&cp__out__, (int)sizeof(CompressionInfo));
+ cp__error__: ;
+ return _res;
+}
+
+static PyObject *Snd_SetSoundPreference(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType theType;
+ Str255 name;
+ Handle settings;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &theType,
+ ResObj_Convert, &settings))
+ return NULL;
+ _err = SetSoundPreference(theType,
+ name,
+ settings);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildStr255, name);
+ return _res;
+}
+
+static PyObject *Snd_GetSoundPreference(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType theType;
+ Str255 name;
+ Handle settings;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &theType,
+ ResObj_Convert, &settings))
+ return NULL;
+ _err = GetSoundPreference(theType,
+ name,
+ settings);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildStr255, name);
+ return _res;
+}
+
+static PyObject *Snd_GetCompressionName(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ OSType compressionType;
+ Str255 compressionName;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &compressionType))
+ return NULL;
+ _err = GetCompressionName(compressionType,
+ compressionName);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildStr255, compressionName);
+ return _res;
+}
+
+static PyObject *Snd_SPBVersion(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ NumVersion _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = SPBVersion();
+ _res = Py_BuildValue("O&",
+ PyMac_BuildNumVersion, _rv);
+ return _res;
+}
+
+static PyObject *Snd_SPBSignInDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short deviceRefNum;
+ Str255 deviceName;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &deviceRefNum,
+ PyMac_GetStr255, deviceName))
+ return NULL;
+ _err = SPBSignInDevice(deviceRefNum,
+ deviceName);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Snd_SPBSignOutDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short deviceRefNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &deviceRefNum))
+ return NULL;
+ _err = SPBSignOutDevice(deviceRefNum);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Snd_SPBGetIndexedDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short count;
+ Str255 deviceName;
+ Handle deviceIconHandle;
+ if (!PyArg_ParseTuple(_args, "h",
+ &count))
+ return NULL;
+ _err = SPBGetIndexedDevice(count,
+ deviceName,
+ &deviceIconHandle);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&",
+ PyMac_BuildStr255, deviceName,
+ ResObj_New, deviceIconHandle);
+ return _res;
+}
+
+static PyObject *Snd_SPBOpenDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Str255 deviceName;
+ short permission;
+ long inRefNum;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetStr255, deviceName,
+ &permission))
+ return NULL;
+ _err = SPBOpenDevice(deviceName,
+ permission,
+ &inRefNum);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ inRefNum);
+ return _res;
+}
+
+static PyObject *Snd_SPBCloseDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long inRefNum;
+ if (!PyArg_ParseTuple(_args, "l",
+ &inRefNum))
+ return NULL;
+ _err = SPBCloseDevice(inRefNum);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Snd_SPBRecord(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SPBPtr inParamPtr;
+ Boolean asynchFlag;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ SPBObj_Convert, &inParamPtr,
+ &asynchFlag))
+ return NULL;
+ _err = SPBRecord(inParamPtr,
+ asynchFlag);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Snd_SPBRecordToFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short fRefNum;
+ SPBPtr inParamPtr;
+ Boolean asynchFlag;
+ if (!PyArg_ParseTuple(_args, "hO&b",
+ &fRefNum,
+ SPBObj_Convert, &inParamPtr,
+ &asynchFlag))
+ return NULL;
+ _err = SPBRecordToFile(fRefNum,
+ inParamPtr,
+ asynchFlag);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Snd_SPBPauseRecording(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long inRefNum;
+ if (!PyArg_ParseTuple(_args, "l",
+ &inRefNum))
+ return NULL;
+ _err = SPBPauseRecording(inRefNum);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Snd_SPBResumeRecording(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long inRefNum;
+ if (!PyArg_ParseTuple(_args, "l",
+ &inRefNum))
+ return NULL;
+ _err = SPBResumeRecording(inRefNum);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Snd_SPBStopRecording(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long inRefNum;
+ if (!PyArg_ParseTuple(_args, "l",
+ &inRefNum))
+ return NULL;
+ _err = SPBStopRecording(inRefNum);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Snd_SPBGetRecordingStatus(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long inRefNum;
+ short recordingStatus;
+ short meterLevel;
+ unsigned long totalSamplesToRecord;
+ unsigned long numberOfSamplesRecorded;
+ unsigned long totalMsecsToRecord;
+ unsigned long numberOfMsecsRecorded;
+ if (!PyArg_ParseTuple(_args, "l",
+ &inRefNum))
+ return NULL;
+ _err = SPBGetRecordingStatus(inRefNum,
+ &recordingStatus,
+ &meterLevel,
+ &totalSamplesToRecord,
+ &numberOfSamplesRecorded,
+ &totalMsecsToRecord,
+ &numberOfMsecsRecorded);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("hhllll",
+ recordingStatus,
+ meterLevel,
+ totalSamplesToRecord,
+ numberOfSamplesRecorded,
+ totalMsecsToRecord,
+ numberOfMsecsRecorded);
+ return _res;
+}
+
+static PyObject *Snd_SPBGetDeviceInfo(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long inRefNum;
+ OSType infoType;
+ void * infoData;
+ if (!PyArg_ParseTuple(_args, "lO&w",
+ &inRefNum,
+ PyMac_GetOSType, &infoType,
+ &infoData))
+ return NULL;
+ _err = SPBGetDeviceInfo(inRefNum,
+ infoType,
+ infoData);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Snd_SPBSetDeviceInfo(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long inRefNum;
+ OSType infoType;
+ void * infoData;
+ if (!PyArg_ParseTuple(_args, "lO&w",
+ &inRefNum,
+ PyMac_GetOSType, &infoType,
+ &infoData))
+ return NULL;
+ _err = SPBSetDeviceInfo(inRefNum,
+ infoType,
+ infoData);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Snd_SPBMillisecondsToBytes(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long inRefNum;
+ long milliseconds;
+ if (!PyArg_ParseTuple(_args, "l",
+ &inRefNum))
+ return NULL;
+ _err = SPBMillisecondsToBytes(inRefNum,
+ &milliseconds);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ milliseconds);
+ return _res;
+}
+
+static PyObject *Snd_SPBBytesToMilliseconds(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long inRefNum;
+ long byteCount;
+ if (!PyArg_ParseTuple(_args, "l",
+ &inRefNum))
+ return NULL;
+ _err = SPBBytesToMilliseconds(inRefNum,
+ &byteCount);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ byteCount);
+ return _res;
+}
+
+static PyMethodDef Snd_methods[] = {
+ {"SPB", (PyCFunction)Snd_SPB, 1,
+ NULL},
+ {"SysBeep", (PyCFunction)Snd_SysBeep, 1,
+ "(short duration) -> None"},
+ {"SndNewChannel", (PyCFunction)Snd_SndNewChannel, 1,
+ "(short synth, long init, PyObject* userRoutine) -> (SndChannelPtr chan)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"SndControl", (PyCFunction)Snd_SndControl, 1,
+ "(short id) -> (SndCommand cmd)"},
+#endif
+ {"SndSoundManagerVersion", (PyCFunction)Snd_SndSoundManagerVersion, 1,
+ "() -> (NumVersion _rv)"},
+ {"SndManagerStatus", (PyCFunction)Snd_SndManagerStatus, 1,
+ "(short theLength) -> (SMStatus theStatus)"},
+ {"SndGetSysBeepState", (PyCFunction)Snd_SndGetSysBeepState, 1,
+ "() -> (short sysBeepState)"},
+ {"SndSetSysBeepState", (PyCFunction)Snd_SndSetSysBeepState, 1,
+ "(short sysBeepState) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+ {"MACEVersion", (PyCFunction)Snd_MACEVersion, 1,
+ "() -> (NumVersion _rv)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"Comp3to1", (PyCFunction)Snd_Comp3to1, 1,
+ "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"Exp1to3", (PyCFunction)Snd_Exp1to3, 1,
+ "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"Comp6to1", (PyCFunction)Snd_Comp6to1, 1,
+ "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"Exp1to6", (PyCFunction)Snd_Exp1to6, 1,
+ "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
+#endif
+ {"GetSysBeepVolume", (PyCFunction)Snd_GetSysBeepVolume, 1,
+ "() -> (long level)"},
+ {"SetSysBeepVolume", (PyCFunction)Snd_SetSysBeepVolume, 1,
+ "(long level) -> None"},
+ {"GetDefaultOutputVolume", (PyCFunction)Snd_GetDefaultOutputVolume, 1,
+ "() -> (long level)"},
+ {"SetDefaultOutputVolume", (PyCFunction)Snd_SetDefaultOutputVolume, 1,
+ "(long level) -> None"},
+ {"GetSoundHeaderOffset", (PyCFunction)Snd_GetSoundHeaderOffset, 1,
+ "(SndListHandle sndHandle) -> (long offset)"},
+ {"GetCompressionInfo", (PyCFunction)Snd_GetCompressionInfo, 1,
+ "(short compressionID, OSType format, short numChannels, short sampleSize) -> (CompressionInfo cp)"},
+ {"SetSoundPreference", (PyCFunction)Snd_SetSoundPreference, 1,
+ "(OSType theType, Handle settings) -> (Str255 name)"},
+ {"GetSoundPreference", (PyCFunction)Snd_GetSoundPreference, 1,
+ "(OSType theType, Handle settings) -> (Str255 name)"},
+ {"GetCompressionName", (PyCFunction)Snd_GetCompressionName, 1,
+ "(OSType compressionType) -> (Str255 compressionName)"},
+ {"SPBVersion", (PyCFunction)Snd_SPBVersion, 1,
+ "() -> (NumVersion _rv)"},
+ {"SPBSignInDevice", (PyCFunction)Snd_SPBSignInDevice, 1,
+ "(short deviceRefNum, Str255 deviceName) -> None"},
+ {"SPBSignOutDevice", (PyCFunction)Snd_SPBSignOutDevice, 1,
+ "(short deviceRefNum) -> None"},
+ {"SPBGetIndexedDevice", (PyCFunction)Snd_SPBGetIndexedDevice, 1,
+ "(short count) -> (Str255 deviceName, Handle deviceIconHandle)"},
+ {"SPBOpenDevice", (PyCFunction)Snd_SPBOpenDevice, 1,
+ "(Str255 deviceName, short permission) -> (long inRefNum)"},
+ {"SPBCloseDevice", (PyCFunction)Snd_SPBCloseDevice, 1,
+ "(long inRefNum) -> None"},
+ {"SPBRecord", (PyCFunction)Snd_SPBRecord, 1,
+ "(SPBPtr inParamPtr, Boolean asynchFlag) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+ {"SPBRecordToFile", (PyCFunction)Snd_SPBRecordToFile, 1,
+ "(short fRefNum, SPBPtr inParamPtr, Boolean asynchFlag) -> None"},
+#endif
+ {"SPBPauseRecording", (PyCFunction)Snd_SPBPauseRecording, 1,
+ "(long inRefNum) -> None"},
+ {"SPBResumeRecording", (PyCFunction)Snd_SPBResumeRecording, 1,
+ "(long inRefNum) -> None"},
+ {"SPBStopRecording", (PyCFunction)Snd_SPBStopRecording, 1,
+ "(long inRefNum) -> None"},
+ {"SPBGetRecordingStatus", (PyCFunction)Snd_SPBGetRecordingStatus, 1,
+ "(long inRefNum) -> (short recordingStatus, short meterLevel, unsigned long totalSamplesToRecord, unsigned long numberOfSamplesRecorded, unsigned long totalMsecsToRecord, unsigned long numberOfMsecsRecorded)"},
+ {"SPBGetDeviceInfo", (PyCFunction)Snd_SPBGetDeviceInfo, 1,
+ "(long inRefNum, OSType infoType, void * infoData) -> None"},
+ {"SPBSetDeviceInfo", (PyCFunction)Snd_SPBSetDeviceInfo, 1,
+ "(long inRefNum, OSType infoType, void * infoData) -> None"},
+ {"SPBMillisecondsToBytes", (PyCFunction)Snd_SPBMillisecondsToBytes, 1,
+ "(long inRefNum) -> (long milliseconds)"},
+ {"SPBBytesToMilliseconds", (PyCFunction)Snd_SPBBytesToMilliseconds, 1,
+ "(long inRefNum) -> (long byteCount)"},
+ {NULL, NULL, 0}
+};
+
+
+
+/* Routine passed to Py_AddPendingCall -- call the Python callback */
+static int
+SndCh_CallCallBack(void *arg)
+{
+ SndChannelObject *p = (SndChannelObject *)arg;
+ PyObject *args;
+ PyObject *res;
+ args = Py_BuildValue("(O(hhl))",
+ p, p->ob_cmd.cmd, p->ob_cmd.param1, p->ob_cmd.param2);
+ res = PyEval_CallObject(p->ob_callback, args);
+ Py_DECREF(args);
+ if (res == NULL)
+ return -1;
+ Py_DECREF(res);
+ return 0;
+}
+
+/* Routine passed to NewSndChannel -- schedule a call to SndCh_CallCallBack */
+static pascal void
+SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd)
+{
+ SndChannelObject *p = (SndChannelObject *)(chan->userInfo);
+ if (p->ob_callback != NULL) {
+ long A5 = SetA5(p->ob_A5);
+ p->ob_cmd = *cmd;
+ Py_AddPendingCall(SndCh_CallCallBack, (void *)p);
+ SetA5(A5);
+ }
+}
+
+/* SPB callbacks - Schedule callbacks to Python */
+static int
+SPB_CallCallBack(void *arg)
+{
+ SPBObject *p = (SPBObject *)arg;
+ PyObject *args;
+ PyObject *res;
+
+ if ( p->ob_thiscallback == 0 ) return 0;
+ args = Py_BuildValue("(O)", p);
+ res = PyEval_CallObject(p->ob_thiscallback, args);
+ p->ob_thiscallback = 0;
+ Py_DECREF(args);
+ if (res == NULL)
+ return -1;
+ Py_DECREF(res);
+ return 0;
+}
+
+static pascal void
+SPB_completion(SPBPtr my_spb)
+{
+ SPBObject *p = (SPBObject *)(my_spb->userLong);
+
+ if (p && p->ob_completion) {
+ long A5 = SetA5(p->ob_A5);
+ p->ob_thiscallback = p->ob_completion; /* Hope we cannot get two at the same time */
+ Py_AddPendingCall(SPB_CallCallBack, (void *)p);
+ SetA5(A5);
+ }
+}
+
+#if !TARGET_API_MAC_CARBON
+static pascal void
+SPB_interrupt(SPBPtr my_spb)
+{
+ SPBObject *p = (SPBObject *)(my_spb->userLong);
+
+ if (p && p->ob_interrupt) {
+ long A5 = SetA5(p->ob_A5);
+ p->ob_thiscallback = p->ob_interrupt; /* Hope we cannot get two at the same time */
+ Py_AddPendingCall(SPB_CallCallBack, (void *)p);
+ SetA5(A5);
+ }
+}
+#endif
+
+
+void init_Snd(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+
+ m = Py_InitModule("_Snd", Snd_methods);
+ d = PyModule_GetDict(m);
+ Snd_Error = PyMac_GetOSErrException();
+ if (Snd_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Snd_Error) != 0)
+ return;
+ SndChannel_Type.ob_type = &PyType_Type;
+ Py_INCREF(&SndChannel_Type);
+ if (PyDict_SetItemString(d, "SndChannelType", (PyObject *)&SndChannel_Type) != 0)
+ Py_FatalError("can't initialize SndChannelType");
+ SPB_Type.ob_type = &PyType_Type;
+ Py_INCREF(&SPB_Type);
+ if (PyDict_SetItemString(d, "SPBType", (PyObject *)&SPB_Type) != 0)
+ Py_FatalError("can't initialize SPBType");
+}
+
+/* ======================== End module _Snd ========================= */
+
--- /dev/null
+
+/* =========================== Module _TE =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <TextEdit.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+extern PyObject *_TEObj_New(TEHandle);
+extern int _TEObj_Convert(PyObject *, TEHandle *);
+
+#define TEObj_New _TEObj_New
+#define TEObj_Convert _TEObj_Convert
+#endif
+
+#define as_TE(h) ((TEHandle)h)
+#define as_Resource(teh) ((Handle)teh)
+
+/*
+** Parse/generate TextStyle records
+*/
+static PyObject *
+TextStyle_New(TextStylePtr itself)
+{
+
+ return Py_BuildValue("lllO&", (long)itself->tsFont, (long)itself->tsFace, (long)itself->tsSize, QdRGB_New,
+ &itself->tsColor);
+}
+
+static int
+TextStyle_Convert(PyObject *v, TextStylePtr p_itself)
+{
+ long font, face, size;
+
+ if( !PyArg_ParseTuple(v, "lllO&", &font, &face, &size, QdRGB_Convert, &p_itself->tsColor) )
+ return 0;
+ p_itself->tsFont = (short)font;
+ p_itself->tsFace = (Style)face;
+ p_itself->tsSize = (short)size;
+ return 1;
+}
+
+static PyObject *TE_Error;
+
+/* ------------------------- Object type TE ------------------------- */
+
+PyTypeObject TE_Type;
+
+#define TEObj_Check(x) ((x)->ob_type == &TE_Type)
+
+typedef struct TEObject {
+ PyObject_HEAD
+ TEHandle ob_itself;
+} TEObject;
+
+PyObject *TEObj_New(TEHandle itself)
+{
+ TEObject *it;
+ if (itself == NULL) {
+ PyErr_SetString(TE_Error,"Cannot create null TE");
+ return NULL;
+ }
+ it = PyObject_NEW(TEObject, &TE_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+TEObj_Convert(PyObject *v, TEHandle *p_itself)
+{
+ if (!TEObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "TE required");
+ return 0;
+ }
+ *p_itself = ((TEObject *)v)->ob_itself;
+ return 1;
+}
+
+static void TEObj_dealloc(TEObject *self)
+{
+ TEDispose(self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *TEObj_TESetText(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ char *text__in__;
+ long text__len__;
+ int text__in_len__;
+ if (!PyArg_ParseTuple(_args, "s#",
+ &text__in__, &text__in_len__))
+ return NULL;
+ text__len__ = text__in_len__;
+ TESetText(text__in__, text__len__,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ text__error__: ;
+ return _res;
+}
+
+static PyObject *TEObj_TEGetText(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CharsHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TEGetText(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TEObj_TEIdle(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TEIdle(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TESetSelect(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long selStart;
+ long selEnd;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &selStart,
+ &selEnd))
+ return NULL;
+ TESetSelect(selStart,
+ selEnd,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TEActivate(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TEActivate(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TEDeactivate(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TEDeactivate(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TEKey(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CharParameter key;
+ if (!PyArg_ParseTuple(_args, "h",
+ &key))
+ return NULL;
+ TEKey(key,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TECut(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TECut(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TECopy(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TECopy(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TEPaste(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TEPaste(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TEDelete(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TEDelete(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TEInsert(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ char *text__in__;
+ long text__len__;
+ int text__in_len__;
+ if (!PyArg_ParseTuple(_args, "s#",
+ &text__in__, &text__in_len__))
+ return NULL;
+ text__len__ = text__in_len__;
+ TEInsert(text__in__, text__len__,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ text__error__: ;
+ return _res;
+}
+
+static PyObject *TEObj_TESetAlignment(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short just;
+ if (!PyArg_ParseTuple(_args, "h",
+ &just))
+ return NULL;
+ TESetAlignment(just,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TEUpdate(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect rUpdate;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &rUpdate))
+ return NULL;
+ TEUpdate(&rUpdate,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TEScroll(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short dh;
+ short dv;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &dh,
+ &dv))
+ return NULL;
+ TEScroll(dh,
+ dv,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TESelView(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TESelView(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TEPinScroll(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short dh;
+ short dv;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &dh,
+ &dv))
+ return NULL;
+ TEPinScroll(dh,
+ dv,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TEAutoView(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean fAuto;
+ if (!PyArg_ParseTuple(_args, "b",
+ &fAuto))
+ return NULL;
+ TEAutoView(fAuto,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TECalText(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TECalText(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TEGetOffset(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ Point pt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &pt))
+ return NULL;
+ _rv = TEGetOffset(pt,
+ _self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *TEObj_TEGetPoint(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point _rv;
+ short offset;
+ if (!PyArg_ParseTuple(_args, "h",
+ &offset))
+ return NULL;
+ _rv = TEGetPoint(offset,
+ _self->ob_itself);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, _rv);
+ return _res;
+}
+
+static PyObject *TEObj_TEClick(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point pt;
+ Boolean fExtend;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ PyMac_GetPoint, &pt,
+ &fExtend))
+ return NULL;
+ TEClick(pt,
+ fExtend,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TESetStyleHandle(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TEStyleHandle theHandle;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &theHandle))
+ return NULL;
+ TESetStyleHandle(theHandle,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TEGetStyleHandle(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TEStyleHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TEGetStyleHandle(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TEObj_TEGetStyle(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short offset;
+ TextStyle theStyle;
+ short lineHeight;
+ short fontAscent;
+ if (!PyArg_ParseTuple(_args, "h",
+ &offset))
+ return NULL;
+ TEGetStyle(offset,
+ &theStyle,
+ &lineHeight,
+ &fontAscent,
+ _self->ob_itself);
+ _res = Py_BuildValue("O&hh",
+ TextStyle_New, &theStyle,
+ lineHeight,
+ fontAscent);
+ return _res;
+}
+
+static PyObject *TEObj_TEStylePaste(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ TEStylePaste(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TESetStyle(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short mode;
+ TextStyle newStyle;
+ Boolean fRedraw;
+ if (!PyArg_ParseTuple(_args, "hO&b",
+ &mode,
+ TextStyle_Convert, &newStyle,
+ &fRedraw))
+ return NULL;
+ TESetStyle(mode,
+ &newStyle,
+ fRedraw,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TEReplaceStyle(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short mode;
+ TextStyle oldStyle;
+ TextStyle newStyle;
+ Boolean fRedraw;
+ if (!PyArg_ParseTuple(_args, "hO&O&b",
+ &mode,
+ TextStyle_Convert, &oldStyle,
+ TextStyle_Convert, &newStyle,
+ &fRedraw))
+ return NULL;
+ TEReplaceStyle(mode,
+ &oldStyle,
+ &newStyle,
+ fRedraw,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TEGetStyleScrapHandle(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ StScrpHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TEGetStyleScrapHandle(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TEObj_TEStyleInsert(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ char *text__in__;
+ long text__len__;
+ int text__in_len__;
+ StScrpHandle hST;
+ if (!PyArg_ParseTuple(_args, "s#O&",
+ &text__in__, &text__in_len__,
+ ResObj_Convert, &hST))
+ return NULL;
+ text__len__ = text__in_len__;
+ TEStyleInsert(text__in__, text__len__,
+ hST,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ text__error__: ;
+ return _res;
+}
+
+static PyObject *TEObj_TEGetHeight(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ long endLine;
+ long startLine;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &endLine,
+ &startLine))
+ return NULL;
+ _rv = TEGetHeight(endLine,
+ startLine,
+ _self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TEObj_TEContinuousStyle(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ short mode;
+ TextStyle aStyle;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &mode,
+ TextStyle_Convert, &aStyle))
+ return NULL;
+ _rv = TEContinuousStyle(&mode,
+ &aStyle,
+ _self->ob_itself);
+ _res = Py_BuildValue("bhO&",
+ _rv,
+ mode,
+ TextStyle_New, &aStyle);
+ return _res;
+}
+
+static PyObject *TEObj_TEUseStyleScrap(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long rangeStart;
+ long rangeEnd;
+ StScrpHandle newStyles;
+ Boolean fRedraw;
+ if (!PyArg_ParseTuple(_args, "llO&b",
+ &rangeStart,
+ &rangeEnd,
+ ResObj_Convert, &newStyles,
+ &fRedraw))
+ return NULL;
+ TEUseStyleScrap(rangeStart,
+ rangeEnd,
+ newStyles,
+ fRedraw,
+ _self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_TENumStyles(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ long rangeStart;
+ long rangeEnd;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &rangeStart,
+ &rangeEnd))
+ return NULL;
+ _rv = TENumStyles(rangeStart,
+ rangeEnd,
+ _self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TEObj_TEFeatureFlag(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ short feature;
+ short action;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &feature,
+ &action))
+ return NULL;
+ _rv = TEFeatureFlag(feature,
+ action,
+ _self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *TEObj_TEGetHiliteRgn(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ RgnHandle region;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, ®ion))
+ return NULL;
+ _err = TEGetHiliteRgn(region,
+ _self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TEObj_as_Resource(TEObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = as_Resource(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyMethodDef TEObj_methods[] = {
+ {"TESetText", (PyCFunction)TEObj_TESetText, 1,
+ "(Buffer text) -> None"},
+ {"TEGetText", (PyCFunction)TEObj_TEGetText, 1,
+ "() -> (CharsHandle _rv)"},
+ {"TEIdle", (PyCFunction)TEObj_TEIdle, 1,
+ "() -> None"},
+ {"TESetSelect", (PyCFunction)TEObj_TESetSelect, 1,
+ "(long selStart, long selEnd) -> None"},
+ {"TEActivate", (PyCFunction)TEObj_TEActivate, 1,
+ "() -> None"},
+ {"TEDeactivate", (PyCFunction)TEObj_TEDeactivate, 1,
+ "() -> None"},
+ {"TEKey", (PyCFunction)TEObj_TEKey, 1,
+ "(CharParameter key) -> None"},
+ {"TECut", (PyCFunction)TEObj_TECut, 1,
+ "() -> None"},
+ {"TECopy", (PyCFunction)TEObj_TECopy, 1,
+ "() -> None"},
+ {"TEPaste", (PyCFunction)TEObj_TEPaste, 1,
+ "() -> None"},
+ {"TEDelete", (PyCFunction)TEObj_TEDelete, 1,
+ "() -> None"},
+ {"TEInsert", (PyCFunction)TEObj_TEInsert, 1,
+ "(Buffer text) -> None"},
+ {"TESetAlignment", (PyCFunction)TEObj_TESetAlignment, 1,
+ "(short just) -> None"},
+ {"TEUpdate", (PyCFunction)TEObj_TEUpdate, 1,
+ "(Rect rUpdate) -> None"},
+ {"TEScroll", (PyCFunction)TEObj_TEScroll, 1,
+ "(short dh, short dv) -> None"},
+ {"TESelView", (PyCFunction)TEObj_TESelView, 1,
+ "() -> None"},
+ {"TEPinScroll", (PyCFunction)TEObj_TEPinScroll, 1,
+ "(short dh, short dv) -> None"},
+ {"TEAutoView", (PyCFunction)TEObj_TEAutoView, 1,
+ "(Boolean fAuto) -> None"},
+ {"TECalText", (PyCFunction)TEObj_TECalText, 1,
+ "() -> None"},
+ {"TEGetOffset", (PyCFunction)TEObj_TEGetOffset, 1,
+ "(Point pt) -> (short _rv)"},
+ {"TEGetPoint", (PyCFunction)TEObj_TEGetPoint, 1,
+ "(short offset) -> (Point _rv)"},
+ {"TEClick", (PyCFunction)TEObj_TEClick, 1,
+ "(Point pt, Boolean fExtend) -> None"},
+ {"TESetStyleHandle", (PyCFunction)TEObj_TESetStyleHandle, 1,
+ "(TEStyleHandle theHandle) -> None"},
+ {"TEGetStyleHandle", (PyCFunction)TEObj_TEGetStyleHandle, 1,
+ "() -> (TEStyleHandle _rv)"},
+ {"TEGetStyle", (PyCFunction)TEObj_TEGetStyle, 1,
+ "(short offset) -> (TextStyle theStyle, short lineHeight, short fontAscent)"},
+ {"TEStylePaste", (PyCFunction)TEObj_TEStylePaste, 1,
+ "() -> None"},
+ {"TESetStyle", (PyCFunction)TEObj_TESetStyle, 1,
+ "(short mode, TextStyle newStyle, Boolean fRedraw) -> None"},
+ {"TEReplaceStyle", (PyCFunction)TEObj_TEReplaceStyle, 1,
+ "(short mode, TextStyle oldStyle, TextStyle newStyle, Boolean fRedraw) -> None"},
+ {"TEGetStyleScrapHandle", (PyCFunction)TEObj_TEGetStyleScrapHandle, 1,
+ "() -> (StScrpHandle _rv)"},
+ {"TEStyleInsert", (PyCFunction)TEObj_TEStyleInsert, 1,
+ "(Buffer text, StScrpHandle hST) -> None"},
+ {"TEGetHeight", (PyCFunction)TEObj_TEGetHeight, 1,
+ "(long endLine, long startLine) -> (long _rv)"},
+ {"TEContinuousStyle", (PyCFunction)TEObj_TEContinuousStyle, 1,
+ "(short mode, TextStyle aStyle) -> (Boolean _rv, short mode, TextStyle aStyle)"},
+ {"TEUseStyleScrap", (PyCFunction)TEObj_TEUseStyleScrap, 1,
+ "(long rangeStart, long rangeEnd, StScrpHandle newStyles, Boolean fRedraw) -> None"},
+ {"TENumStyles", (PyCFunction)TEObj_TENumStyles, 1,
+ "(long rangeStart, long rangeEnd) -> (long _rv)"},
+ {"TEFeatureFlag", (PyCFunction)TEObj_TEFeatureFlag, 1,
+ "(short feature, short action) -> (short _rv)"},
+ {"TEGetHiliteRgn", (PyCFunction)TEObj_TEGetHiliteRgn, 1,
+ "(RgnHandle region) -> None"},
+ {"as_Resource", (PyCFunction)TEObj_as_Resource, 1,
+ "() -> (Handle _rv)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain TEObj_chain = { TEObj_methods, NULL };
+
+static PyObject *TEObj_getattr(TEObject *self, char *name)
+{
+
+ if( strcmp(name, "destRect") == 0 )
+ return Py_BuildValue("O&", PyMac_BuildRect,
+ &(*self->ob_itself)->destRect);
+ if( strcmp(name, "viewRect") == 0 )
+ return Py_BuildValue("O&", PyMac_BuildRect,
+ &(*self->ob_itself)->viewRect);
+ if( strcmp(name, "selRect") == 0 )
+ return Py_BuildValue("O&", PyMac_BuildRect,
+ &(*self->ob_itself)->selRect);
+ if( strcmp(name, "lineHeight") == 0 )
+ return Py_BuildValue("h", (*self->ob_itself)->lineHeight);
+ if( strcmp(name, "fontAscent") == 0 )
+ return Py_BuildValue("h", (*self->ob_itself)->fontAscent);
+ if( strcmp(name, "selPoint") == 0 )
+ return Py_BuildValue("O&", PyMac_BuildPoint,
+ (*self->ob_itself)->selPoint);
+ if( strcmp(name, "selStart") == 0 )
+ return Py_BuildValue("h", (*self->ob_itself)->selStart);
+ if( strcmp(name, "selEnd") == 0 )
+ return Py_BuildValue("h", (*self->ob_itself)->selEnd);
+ if( strcmp(name, "active") == 0 )
+ return Py_BuildValue("h", (*self->ob_itself)->active);
+ if( strcmp(name, "just") == 0 )
+ return Py_BuildValue("h", (*self->ob_itself)->just);
+ if( strcmp(name, "teLength") == 0 )
+ return Py_BuildValue("h", (*self->ob_itself)->teLength);
+ if( strcmp(name, "txFont") == 0 )
+ return Py_BuildValue("h", (*self->ob_itself)->txFont);
+ if( strcmp(name, "txFace") == 0 )
+ return Py_BuildValue("h", (*self->ob_itself)->txFace);
+ if( strcmp(name, "txMode") == 0 )
+ return Py_BuildValue("h", (*self->ob_itself)->txMode);
+ if( strcmp(name, "txSize") == 0 )
+ return Py_BuildValue("h", (*self->ob_itself)->txSize);
+ if( strcmp(name, "nLines") == 0 )
+ return Py_BuildValue("h", (*self->ob_itself)->nLines);
+
+ return Py_FindMethodInChain(&TEObj_chain, (PyObject *)self, name);
+}
+
+#define TEObj_setattr NULL
+
+#define TEObj_compare NULL
+
+#define TEObj_repr NULL
+
+#define TEObj_hash NULL
+
+PyTypeObject TE_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "TE", /*tp_name*/
+ sizeof(TEObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) TEObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) TEObj_getattr, /*tp_getattr*/
+ (setattrfunc) TEObj_setattr, /*tp_setattr*/
+ (cmpfunc) TEObj_compare, /*tp_compare*/
+ (reprfunc) TEObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) TEObj_hash, /*tp_hash*/
+};
+
+/* ----------------------- End object type TE ----------------------- */
+
+
+static PyObject *TE_TEScrapHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TEScrapHandle();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TE_TEGetScrapLength(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TEGetScrapLength();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *TE_TENew(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TEHandle _rv;
+ Rect destRect;
+ Rect viewRect;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &destRect,
+ PyMac_GetRect, &viewRect))
+ return NULL;
+ _rv = TENew(&destRect,
+ &viewRect);
+ _res = Py_BuildValue("O&",
+ TEObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TE_TETextBox(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ char *text__in__;
+ long text__len__;
+ int text__in_len__;
+ Rect box;
+ short just;
+ if (!PyArg_ParseTuple(_args, "s#O&h",
+ &text__in__, &text__in_len__,
+ PyMac_GetRect, &box,
+ &just))
+ return NULL;
+ text__len__ = text__in_len__;
+ TETextBox(text__in__, text__len__,
+ &box,
+ just);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ text__error__: ;
+ return _res;
+}
+
+static PyObject *TE_TEStyleNew(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TEHandle _rv;
+ Rect destRect;
+ Rect viewRect;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &destRect,
+ PyMac_GetRect, &viewRect))
+ return NULL;
+ _rv = TEStyleNew(&destRect,
+ &viewRect);
+ _res = Py_BuildValue("O&",
+ TEObj_New, _rv);
+ return _res;
+}
+
+static PyObject *TE_TESetScrapLength(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long length;
+ if (!PyArg_ParseTuple(_args, "l",
+ &length))
+ return NULL;
+ TESetScrapLength(length);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TE_TEFromScrap(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = TEFromScrap();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *TE_TEToScrap(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = TEToScrap();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *TE_TEGetScrapHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TEGetScrapHandle();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *TE_TESetScrapHandle(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Handle value;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &value))
+ return NULL;
+ TESetScrapHandle(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *TE_as_TE(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ TEHandle _rv;
+ Handle h;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &h))
+ return NULL;
+ _rv = as_TE(h);
+ _res = Py_BuildValue("O&",
+ TEObj_New, _rv);
+ return _res;
+}
+
+static PyMethodDef TE_methods[] = {
+ {"TEScrapHandle", (PyCFunction)TE_TEScrapHandle, 1,
+ "() -> (Handle _rv)"},
+ {"TEGetScrapLength", (PyCFunction)TE_TEGetScrapLength, 1,
+ "() -> (long _rv)"},
+ {"TENew", (PyCFunction)TE_TENew, 1,
+ "(Rect destRect, Rect viewRect) -> (TEHandle _rv)"},
+ {"TETextBox", (PyCFunction)TE_TETextBox, 1,
+ "(Buffer text, Rect box, short just) -> None"},
+ {"TEStyleNew", (PyCFunction)TE_TEStyleNew, 1,
+ "(Rect destRect, Rect viewRect) -> (TEHandle _rv)"},
+ {"TESetScrapLength", (PyCFunction)TE_TESetScrapLength, 1,
+ "(long length) -> None"},
+ {"TEFromScrap", (PyCFunction)TE_TEFromScrap, 1,
+ "() -> None"},
+ {"TEToScrap", (PyCFunction)TE_TEToScrap, 1,
+ "() -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"TEGetScrapHandle", (PyCFunction)TE_TEGetScrapHandle, 1,
+ "() -> (Handle _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"TESetScrapHandle", (PyCFunction)TE_TESetScrapHandle, 1,
+ "(Handle value) -> None"},
+#endif
+ {"as_TE", (PyCFunction)TE_as_TE, 1,
+ "(Handle h) -> (TEHandle _rv)"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void init_TE(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(TEHandle, TEObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(TEHandle, TEObj_Convert);
+
+
+ m = Py_InitModule("_TE", TE_methods);
+ d = PyModule_GetDict(m);
+ TE_Error = PyMac_GetOSErrException();
+ if (TE_Error == NULL ||
+ PyDict_SetItemString(d, "Error", TE_Error) != 0)
+ return;
+ TE_Type.ob_type = &PyType_Type;
+ Py_INCREF(&TE_Type);
+ if (PyDict_SetItemString(d, "TEType", (PyObject *)&TE_Type) != 0)
+ Py_FatalError("can't initialize TEType");
+}
+
+/* ========================= End module _TE ========================= */
+
--- /dev/null
+
+/* ========================== Module _Win =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* 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)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Windows.h>
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+extern PyObject *_WinObj_New(WindowRef);
+extern PyObject *_WinObj_WhichWindow(WindowRef);
+extern int _WinObj_Convert(PyObject *, WindowRef *);
+
+#define WinObj_New _WinObj_New
+#define WinObj_WhichWindow _WinObj_WhichWindow
+#define WinObj_Convert _WinObj_Convert
+#endif
+
+#if !ACCESSOR_CALLS_ARE_FUNCTIONS
+/* Carbon calls that we emulate in classic mode */
+#define GetWindowSpareFlag(win) (((CWindowPeek)(win))->spareFlag)
+#define GetWindowFromPort(port) ((WindowRef)(port))
+#define GetWindowPortBounds(win, rectp) (*(rectp) = ((CWindowPeek)(win))->port.portRect)
+#define IsPointerValid(p) (((long)p&3) == 0)
+#endif
+#if ACCESSOR_CALLS_ARE_FUNCTIONS
+/* Classic calls that we emulate in carbon mode */
+#define GetWindowUpdateRgn(win, rgn) GetWindowRegion((win), kWindowUpdateRgn, (rgn))
+#define GetWindowStructureRgn(win, rgn) GetWindowRegion((win), kWindowStructureRgn, (rgn))
+#define GetWindowContentRgn(win, rgn) GetWindowRegion((win), kWindowContentRgn, (rgn))
+#endif
+
+/* Function to dispose a window, with a "normal" calling sequence */
+static void
+PyMac_AutoDisposeWindow(WindowPtr w)
+{
+ DisposeWindow(w);
+}
+
+static PyObject *Win_Error;
+
+/* ----------------------- Object type Window ----------------------- */
+
+PyTypeObject Window_Type;
+
+#define WinObj_Check(x) ((x)->ob_type == &Window_Type)
+
+typedef struct WindowObject {
+ PyObject_HEAD
+ WindowPtr ob_itself;
+ void (*ob_freeit)(WindowPtr ptr);
+} WindowObject;
+
+PyObject *WinObj_New(WindowPtr itself)
+{
+ WindowObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(WindowObject, &Window_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_freeit = NULL;
+ if (GetWRefCon(itself) == 0)
+ {
+ SetWRefCon(itself, (long)it);
+ it->ob_freeit = PyMac_AutoDisposeWindow;
+ }
+ return (PyObject *)it;
+}
+WinObj_Convert(PyObject *v, WindowPtr *p_itself)
+{
+
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ if (PyInt_Check(v)) { *p_itself = (WindowPtr)PyInt_AsLong(v); return 1; }
+
+ {
+ DialogRef dlg;
+ if (DlgObj_Convert(v, &dlg) && dlg) {
+ *p_itself = GetDialogWindow(dlg);
+ return 1;
+ }
+ PyErr_Clear();
+ }
+ if (!WinObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "Window required");
+ return 0;
+ }
+ *p_itself = ((WindowObject *)v)->ob_itself;
+ return 1;
+}
+
+static void WinObj_dealloc(WindowObject *self)
+{
+ if (self->ob_freeit && self->ob_itself)
+ {
+ SetWRefCon(self->ob_itself, 0);
+ self->ob_freeit(self->ob_itself);
+ }
+ self->ob_itself = NULL;
+ self->ob_freeit = NULL;
+ PyMem_DEL(self);
+}
+
+static PyObject *WinObj_GetWindowOwnerCount(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ UInt32 outCount;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetWindowOwnerCount(_self->ob_itself,
+ &outCount);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outCount);
+ return _res;
+}
+
+static PyObject *WinObj_CloneWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = CloneWindow(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_ReshapeCustomWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = ReshapeCustomWindow(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *WinObj_GetWindowClass(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowClass outClass;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetWindowClass(_self->ob_itself,
+ &outClass);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outClass);
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowAttributes(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowAttributes outAttributes;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetWindowAttributes(_self->ob_itself,
+ &outAttributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outAttributes);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_ChangeWindowAttributes(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowAttributes setTheseAttributes;
+ WindowAttributes clearTheseAttributes;
+ if (!PyArg_ParseTuple(_args, "ll",
+ &setTheseAttributes,
+ &clearTheseAttributes))
+ return NULL;
+ _err = ChangeWindowAttributes(_self->ob_itself,
+ setTheseAttributes,
+ clearTheseAttributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_SetWinColor(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WCTabHandle newColorTable;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &newColorTable))
+ return NULL;
+ SetWinColor(_self->ob_itself,
+ newColorTable);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *WinObj_SetWindowContentColor(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ RGBColor color;
+ if (!PyArg_ParseTuple(_args, "O&",
+ QdRGB_Convert, &color))
+ return NULL;
+ _err = SetWindowContentColor(_self->ob_itself,
+ &color);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowContentColor(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ RGBColor color;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetWindowContentColor(_self->ob_itself,
+ &color);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ QdRGB_New, &color);
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowContentPattern(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ PixPatHandle outPixPat;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &outPixPat))
+ return NULL;
+ _err = GetWindowContentPattern(_self->ob_itself,
+ outPixPat);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_SetWindowContentPattern(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ PixPatHandle pixPat;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pixPat))
+ return NULL;
+ _err = SetWindowContentPattern(_self->ob_itself,
+ pixPat);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_ScrollWindowRect(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect inScrollRect;
+ SInt16 inHPixels;
+ SInt16 inVPixels;
+ ScrollWindowOptions inOptions;
+ RgnHandle outExposedRgn;
+ if (!PyArg_ParseTuple(_args, "O&hhlO&",
+ PyMac_GetRect, &inScrollRect,
+ &inHPixels,
+ &inVPixels,
+ &inOptions,
+ ResObj_Convert, &outExposedRgn))
+ return NULL;
+ _err = ScrollWindowRect(_self->ob_itself,
+ &inScrollRect,
+ inHPixels,
+ inVPixels,
+ inOptions,
+ outExposedRgn);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_ScrollWindowRegion(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ RgnHandle inScrollRgn;
+ SInt16 inHPixels;
+ SInt16 inVPixels;
+ ScrollWindowOptions inOptions;
+ RgnHandle outExposedRgn;
+ if (!PyArg_ParseTuple(_args, "O&hhlO&",
+ ResObj_Convert, &inScrollRgn,
+ &inHPixels,
+ &inVPixels,
+ &inOptions,
+ ResObj_Convert, &outExposedRgn))
+ return NULL;
+ _err = ScrollWindowRegion(_self->ob_itself,
+ inScrollRgn,
+ inHPixels,
+ inVPixels,
+ inOptions,
+ outExposedRgn);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *WinObj_ClipAbove(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ClipAbove(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_SaveOld(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ SaveOld(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_DrawNew(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean update;
+ if (!PyArg_ParseTuple(_args, "b",
+ &update))
+ return NULL;
+ DrawNew(_self->ob_itself,
+ update);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *WinObj_PaintOne(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle clobberedRgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &clobberedRgn))
+ return NULL;
+ PaintOne(_self->ob_itself,
+ clobberedRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_PaintBehind(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle clobberedRgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &clobberedRgn))
+ return NULL;
+ PaintBehind(_self->ob_itself,
+ clobberedRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_CalcVis(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ CalcVis(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_CalcVisBehind(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle clobberedRgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &clobberedRgn))
+ return NULL;
+ CalcVisBehind(_self->ob_itself,
+ clobberedRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_BringToFront(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ BringToFront(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_SendBehind(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr behindWindow;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &behindWindow))
+ return NULL;
+ SendBehind(_self->ob_itself,
+ behindWindow);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_SelectWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ SelectWindow(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_GetNextWindowOfClass(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ WindowClass inWindowClass;
+ Boolean mustBeVisible;
+ if (!PyArg_ParseTuple(_args, "lb",
+ &inWindowClass,
+ &mustBeVisible))
+ return NULL;
+ _rv = GetNextWindowOfClass(_self->ob_itself,
+ inWindowClass,
+ mustBeVisible);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_IsValidWindowPtr(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsValidWindowPtr(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *WinObj_HiliteWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean fHilite;
+ if (!PyArg_ParseTuple(_args, "b",
+ &fHilite))
+ return NULL;
+ HiliteWindow(_self->ob_itself,
+ fHilite);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_SetWRefCon(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long data;
+ if (!PyArg_ParseTuple(_args, "l",
+ &data))
+ return NULL;
+ SetWRefCon(_self->ob_itself,
+ data);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_GetWRefCon(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetWRefCon(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_SetWindowPic(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PicHandle pic;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &pic))
+ return NULL;
+ SetWindowPic(_self->ob_itself,
+ pic);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowPic(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PicHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetWindowPic(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *WinObj_GetWVariant(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetWVariant(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowFeatures(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ UInt32 outFeatures;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetWindowFeatures(_self->ob_itself,
+ &outFeatures);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outFeatures);
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowRegion(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowRegionCode inRegionCode;
+ RgnHandle ioWinRgn;
+ if (!PyArg_ParseTuple(_args, "HO&",
+ &inRegionCode,
+ ResObj_Convert, &ioWinRgn))
+ return NULL;
+ _err = GetWindowRegion(_self->ob_itself,
+ inRegionCode,
+ ioWinRgn);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_BeginUpdate(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ BeginUpdate(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_EndUpdate(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ EndUpdate(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_InvalWindowRgn(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ RgnHandle region;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, ®ion))
+ return NULL;
+ _err = InvalWindowRgn(_self->ob_itself,
+ region);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_InvalWindowRect(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect bounds;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &bounds))
+ return NULL;
+ _err = InvalWindowRect(_self->ob_itself,
+ &bounds);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_ValidWindowRgn(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ RgnHandle region;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, ®ion))
+ return NULL;
+ _err = ValidWindowRgn(_self->ob_itself,
+ region);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_ValidWindowRect(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect bounds;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &bounds))
+ return NULL;
+ _err = ValidWindowRect(_self->ob_itself,
+ &bounds);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_DrawGrowIcon(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DrawGrowIcon(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_SetWTitle(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Str255 title;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, title))
+ return NULL;
+ SetWTitle(_self->ob_itself,
+ title);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_GetWTitle(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Str255 title;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetWTitle(_self->ob_itself,
+ title);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildStr255, title);
+ return _res;
+}
+
+static PyObject *WinObj_SetWindowProxyFSSpec(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ FSSpec inFile;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFSSpec, &inFile))
+ return NULL;
+ _err = SetWindowProxyFSSpec(_self->ob_itself,
+ &inFile);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowProxyFSSpec(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ FSSpec outFile;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetWindowProxyFSSpec(_self->ob_itself,
+ &outFile);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildFSSpec, outFile);
+ return _res;
+}
+
+static PyObject *WinObj_SetWindowProxyAlias(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ AliasHandle alias;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &alias))
+ return NULL;
+ _err = SetWindowProxyAlias(_self->ob_itself,
+ alias);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowProxyAlias(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ AliasHandle alias;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetWindowProxyAlias(_self->ob_itself,
+ &alias);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, alias);
+ return _res;
+}
+
+static PyObject *WinObj_SetWindowProxyCreatorAndType(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ OSType fileCreator;
+ OSType fileType;
+ SInt16 vRefNum;
+ if (!PyArg_ParseTuple(_args, "O&O&h",
+ PyMac_GetOSType, &fileCreator,
+ PyMac_GetOSType, &fileType,
+ &vRefNum))
+ return NULL;
+ _err = SetWindowProxyCreatorAndType(_self->ob_itself,
+ fileCreator,
+ fileType,
+ vRefNum);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowProxyIcon(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ IconRef outIcon;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetWindowProxyIcon(_self->ob_itself,
+ &outIcon);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ ResObj_New, outIcon);
+ return _res;
+}
+
+static PyObject *WinObj_SetWindowProxyIcon(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ IconRef icon;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &icon))
+ return NULL;
+ _err = SetWindowProxyIcon(_self->ob_itself,
+ icon);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_RemoveWindowProxy(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = RemoveWindowProxy(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_BeginWindowProxyDrag(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ DragReference outNewDrag;
+ RgnHandle outDragOutlineRgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &outDragOutlineRgn))
+ return NULL;
+ _err = BeginWindowProxyDrag(_self->ob_itself,
+ &outNewDrag,
+ outDragOutlineRgn);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ DragObj_New, outNewDrag);
+ return _res;
+}
+
+static PyObject *WinObj_EndWindowProxyDrag(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ DragReference theDrag;
+ if (!PyArg_ParseTuple(_args, "O&",
+ DragObj_Convert, &theDrag))
+ return NULL;
+ _err = EndWindowProxyDrag(_self->ob_itself,
+ theDrag);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_TrackWindowProxyFromExistingDrag(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Point startPt;
+ DragReference drag;
+ RgnHandle inDragOutlineRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&O&",
+ PyMac_GetPoint, &startPt,
+ DragObj_Convert, &drag,
+ ResObj_Convert, &inDragOutlineRgn))
+ return NULL;
+ _err = TrackWindowProxyFromExistingDrag(_self->ob_itself,
+ startPt,
+ drag,
+ inDragOutlineRgn);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_TrackWindowProxyDrag(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Point startPt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &startPt))
+ return NULL;
+ _err = TrackWindowProxyDrag(_self->ob_itself,
+ startPt);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_IsWindowModified(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsWindowModified(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_SetWindowModified(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Boolean modified;
+ if (!PyArg_ParseTuple(_args, "b",
+ &modified))
+ return NULL;
+ _err = SetWindowModified(_self->ob_itself,
+ modified);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_IsWindowPathSelectClick(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventRecord event;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &event))
+ return NULL;
+ _rv = IsWindowPathSelectClick(_self->ob_itself,
+ &event);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_WindowPathSelect(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuHandle menu;
+ SInt32 outMenuResult;
+ if (!PyArg_ParseTuple(_args, "O&",
+ MenuObj_Convert, &menu))
+ return NULL;
+ _err = WindowPathSelect(_self->ob_itself,
+ menu,
+ &outMenuResult);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outMenuResult);
+ return _res;
+}
+
+static PyObject *WinObj_HiliteWindowFrameForDrag(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Boolean hilited;
+ if (!PyArg_ParseTuple(_args, "b",
+ &hilited))
+ return NULL;
+ _err = HiliteWindowFrameForDrag(_self->ob_itself,
+ hilited);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_TransitionWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowTransitionEffect effect;
+ WindowTransitionAction action;
+ Rect rect;
+ if (!PyArg_ParseTuple(_args, "llO&",
+ &effect,
+ &action,
+ PyMac_GetRect, &rect))
+ return NULL;
+ _err = TransitionWindow(_self->ob_itself,
+ effect,
+ action,
+ &rect);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_MacMoveWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short hGlobal;
+ short vGlobal;
+ Boolean front;
+ if (!PyArg_ParseTuple(_args, "hhb",
+ &hGlobal,
+ &vGlobal,
+ &front))
+ return NULL;
+ MacMoveWindow(_self->ob_itself,
+ hGlobal,
+ vGlobal,
+ front);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_SizeWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short w;
+ short h;
+ Boolean fUpdate;
+ if (!PyArg_ParseTuple(_args, "hhb",
+ &w,
+ &h,
+ &fUpdate))
+ return NULL;
+ SizeWindow(_self->ob_itself,
+ w,
+ h,
+ fUpdate);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_GrowWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ Point startPt;
+ Rect bBox;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &startPt,
+ PyMac_GetRect, &bBox))
+ return NULL;
+ _rv = GrowWindow(_self->ob_itself,
+ startPt,
+ &bBox);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_DragWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Point startPt;
+ Rect boundsRect;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &startPt,
+ PyMac_GetRect, &boundsRect))
+ return NULL;
+ DragWindow(_self->ob_itself,
+ startPt,
+ &boundsRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_ZoomWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPartCode partCode;
+ Boolean front;
+ if (!PyArg_ParseTuple(_args, "hb",
+ &partCode,
+ &front))
+ return NULL;
+ ZoomWindow(_self->ob_itself,
+ partCode,
+ front);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_IsWindowCollapsable(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsWindowCollapsable(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_IsWindowCollapsed(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsWindowCollapsed(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_CollapseWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Boolean collapse;
+ if (!PyArg_ParseTuple(_args, "b",
+ &collapse))
+ return NULL;
+ _err = CollapseWindow(_self->ob_itself,
+ collapse);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowBounds(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowRegionCode regionCode;
+ Rect globalBounds;
+ if (!PyArg_ParseTuple(_args, "H",
+ ®ionCode))
+ return NULL;
+ _err = GetWindowBounds(_self->ob_itself,
+ regionCode,
+ &globalBounds);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &globalBounds);
+ return _res;
+}
+
+static PyObject *WinObj_ResizeWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point startPoint;
+ Rect sizeConstraints;
+ Rect newContentRect;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &startPoint,
+ PyMac_GetRect, &sizeConstraints))
+ return NULL;
+ _rv = ResizeWindow(_self->ob_itself,
+ startPoint,
+ &sizeConstraints,
+ &newContentRect);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildRect, &newContentRect);
+ return _res;
+}
+
+static PyObject *WinObj_SetWindowBounds(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowRegionCode regionCode;
+ Rect globalBounds;
+ if (!PyArg_ParseTuple(_args, "HO&",
+ ®ionCode,
+ PyMac_GetRect, &globalBounds))
+ return NULL;
+ _err = SetWindowBounds(_self->ob_itself,
+ regionCode,
+ &globalBounds);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_RepositionWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowPtr parentWindow;
+ WindowPositionMethod method;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ WinObj_Convert, &parentWindow,
+ &method))
+ return NULL;
+ _err = RepositionWindow(_self->ob_itself,
+ parentWindow,
+ method);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_MoveWindowStructure(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ short hGlobal;
+ short vGlobal;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &hGlobal,
+ &vGlobal))
+ return NULL;
+ _err = MoveWindowStructure(_self->ob_itself,
+ hGlobal,
+ vGlobal);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_IsWindowInStandardState(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point idealSize;
+ Rect idealStandardState;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsWindowInStandardState(_self->ob_itself,
+ &idealSize,
+ &idealStandardState);
+ _res = Py_BuildValue("bO&O&",
+ _rv,
+ PyMac_BuildPoint, idealSize,
+ PyMac_BuildRect, &idealStandardState);
+ return _res;
+}
+
+static PyObject *WinObj_ZoomWindowIdeal(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowPartCode partCode;
+ Point ioIdealSize;
+ if (!PyArg_ParseTuple(_args, "h",
+ &partCode))
+ return NULL;
+ _err = ZoomWindowIdeal(_self->ob_itself,
+ partCode,
+ &ioIdealSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, ioIdealSize);
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowIdealUserState(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect userState;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetWindowIdealUserState(_self->ob_itself,
+ &userState);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &userState);
+ return _res;
+}
+
+static PyObject *WinObj_SetWindowIdealUserState(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Rect userState;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = SetWindowIdealUserState(_self->ob_itself,
+ &userState);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &userState);
+ return _res;
+}
+
+static PyObject *WinObj_HideWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ HideWindow(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_MacShowWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ MacShowWindow(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_ShowHide(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean showFlag;
+ if (!PyArg_ParseTuple(_args, "b",
+ &showFlag))
+ return NULL;
+ ShowHide(_self->ob_itself,
+ showFlag);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_GetWindowPropertyAttributes(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ OSType propertyCreator;
+ OSType propertyTag;
+ UInt32 attributes;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &propertyCreator,
+ PyMac_GetOSType, &propertyTag))
+ return NULL;
+ _err = GetWindowPropertyAttributes(_self->ob_itself,
+ propertyCreator,
+ propertyTag,
+ &attributes);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ attributes);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_ChangeWindowPropertyAttributes(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ OSType propertyCreator;
+ OSType propertyTag;
+ UInt32 attributesToSet;
+ UInt32 attributesToClear;
+ if (!PyArg_ParseTuple(_args, "O&O&ll",
+ PyMac_GetOSType, &propertyCreator,
+ PyMac_GetOSType, &propertyTag,
+ &attributesToSet,
+ &attributesToClear))
+ return NULL;
+ _err = ChangeWindowPropertyAttributes(_self->ob_itself,
+ propertyCreator,
+ propertyTag,
+ attributesToSet,
+ attributesToClear);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *WinObj_TrackBox(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point thePt;
+ WindowPartCode partCode;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetPoint, &thePt,
+ &partCode))
+ return NULL;
+ _rv = TrackBox(_self->ob_itself,
+ thePt,
+ partCode);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_TrackGoAway(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point thePt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &thePt))
+ return NULL;
+ _rv = TrackGoAway(_self->ob_itself,
+ thePt);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_GetAuxWin(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ AuxWinHandle awHndl;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetAuxWin(_self->ob_itself,
+ &awHndl);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ ResObj_New, awHndl);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_GetWindowGoAwayFlag(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetWindowGoAwayFlag(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_GetWindowSpareFlag(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetWindowSpareFlag(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *WinObj_GetWindowPort(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetWindowPort(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ GrafObj_New, _rv);
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowKind(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetWindowKind(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_MacIsWindowVisible(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MacIsWindowVisible(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_IsWindowHilited(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsWindowHilited(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_IsWindowUpdatePending(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsWindowUpdatePending(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *WinObj_MacGetNextWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MacGetNextWindow(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowStandardState(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect rect;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetWindowStandardState(_self->ob_itself,
+ &rect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &rect);
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowUserState(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect rect;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetWindowUserState(_self->ob_itself,
+ &rect);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &rect);
+ return _res;
+}
+
+static PyObject *WinObj_SetWindowKind(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short kind;
+ if (!PyArg_ParseTuple(_args, "h",
+ &kind))
+ return NULL;
+ SetWindowKind(_self->ob_itself,
+ kind);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_SetWindowStandardState(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect rect;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &rect))
+ return NULL;
+ SetWindowStandardState(_self->ob_itself,
+ &rect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_SetWindowUserState(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect rect;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &rect))
+ return NULL;
+ SetWindowUserState(_self->ob_itself,
+ &rect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_SetPortWindowPort(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ SetPortWindowPort(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowPortBounds(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect bounds;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetWindowPortBounds(_self->ob_itself,
+ &bounds);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &bounds);
+ return _res;
+}
+
+static PyObject *WinObj_IsWindowVisible(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsWindowVisible(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_GetWindowZoomFlag(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetWindowZoomFlag(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *WinObj_GetWindowStructureRgn(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &r))
+ return NULL;
+ GetWindowStructureRgn(_self->ob_itself,
+ r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowContentRgn(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &r))
+ return NULL;
+ GetWindowContentRgn(_self->ob_itself,
+ r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_GetWindowUpdateRgn(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &r))
+ return NULL;
+ GetWindowUpdateRgn(_self->ob_itself,
+ r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_GetWindowTitleWidth(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetWindowTitleWidth(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+#endif
+
+static PyObject *WinObj_GetNextWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetNextWindow(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ WinObj_WhichWindow, _rv);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *WinObj_CloseWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ CloseWindow(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *WinObj_MoveWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short hGlobal;
+ short vGlobal;
+ Boolean front;
+ if (!PyArg_ParseTuple(_args, "hhb",
+ &hGlobal,
+ &vGlobal,
+ &front))
+ return NULL;
+ MoveWindow(_self->ob_itself,
+ hGlobal,
+ vGlobal,
+ front);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_ShowWindow(WindowObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ShowWindow(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef WinObj_methods[] = {
+ {"GetWindowOwnerCount", (PyCFunction)WinObj_GetWindowOwnerCount, 1,
+ "() -> (UInt32 outCount)"},
+ {"CloneWindow", (PyCFunction)WinObj_CloneWindow, 1,
+ "() -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"ReshapeCustomWindow", (PyCFunction)WinObj_ReshapeCustomWindow, 1,
+ "() -> None"},
+#endif
+ {"GetWindowClass", (PyCFunction)WinObj_GetWindowClass, 1,
+ "() -> (WindowClass outClass)"},
+ {"GetWindowAttributes", (PyCFunction)WinObj_GetWindowAttributes, 1,
+ "() -> (WindowAttributes outAttributes)"},
+
+#if TARGET_API_MAC_CARBON
+ {"ChangeWindowAttributes", (PyCFunction)WinObj_ChangeWindowAttributes, 1,
+ "(WindowAttributes setTheseAttributes, WindowAttributes clearTheseAttributes) -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"SetWinColor", (PyCFunction)WinObj_SetWinColor, 1,
+ "(WCTabHandle newColorTable) -> None"},
+#endif
+ {"SetWindowContentColor", (PyCFunction)WinObj_SetWindowContentColor, 1,
+ "(RGBColor color) -> None"},
+ {"GetWindowContentColor", (PyCFunction)WinObj_GetWindowContentColor, 1,
+ "() -> (RGBColor color)"},
+ {"GetWindowContentPattern", (PyCFunction)WinObj_GetWindowContentPattern, 1,
+ "(PixPatHandle outPixPat) -> None"},
+ {"SetWindowContentPattern", (PyCFunction)WinObj_SetWindowContentPattern, 1,
+ "(PixPatHandle pixPat) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"ScrollWindowRect", (PyCFunction)WinObj_ScrollWindowRect, 1,
+ "(Rect inScrollRect, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"ScrollWindowRegion", (PyCFunction)WinObj_ScrollWindowRegion, 1,
+ "(RgnHandle inScrollRgn, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None"},
+#endif
+ {"ClipAbove", (PyCFunction)WinObj_ClipAbove, 1,
+ "() -> None"},
+
+#if !TARGET_API_MAC_CARBON
+ {"SaveOld", (PyCFunction)WinObj_SaveOld, 1,
+ "() -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"DrawNew", (PyCFunction)WinObj_DrawNew, 1,
+ "(Boolean update) -> None"},
+#endif
+ {"PaintOne", (PyCFunction)WinObj_PaintOne, 1,
+ "(RgnHandle clobberedRgn) -> None"},
+ {"PaintBehind", (PyCFunction)WinObj_PaintBehind, 1,
+ "(RgnHandle clobberedRgn) -> None"},
+ {"CalcVis", (PyCFunction)WinObj_CalcVis, 1,
+ "() -> None"},
+ {"CalcVisBehind", (PyCFunction)WinObj_CalcVisBehind, 1,
+ "(RgnHandle clobberedRgn) -> None"},
+ {"BringToFront", (PyCFunction)WinObj_BringToFront, 1,
+ "() -> None"},
+ {"SendBehind", (PyCFunction)WinObj_SendBehind, 1,
+ "(WindowPtr behindWindow) -> None"},
+ {"SelectWindow", (PyCFunction)WinObj_SelectWindow, 1,
+ "() -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"GetNextWindowOfClass", (PyCFunction)WinObj_GetNextWindowOfClass, 1,
+ "(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"IsValidWindowPtr", (PyCFunction)WinObj_IsValidWindowPtr, 1,
+ "() -> (Boolean _rv)"},
+#endif
+ {"HiliteWindow", (PyCFunction)WinObj_HiliteWindow, 1,
+ "(Boolean fHilite) -> None"},
+ {"SetWRefCon", (PyCFunction)WinObj_SetWRefCon, 1,
+ "(long data) -> None"},
+ {"GetWRefCon", (PyCFunction)WinObj_GetWRefCon, 1,
+ "() -> (long _rv)"},
+ {"SetWindowPic", (PyCFunction)WinObj_SetWindowPic, 1,
+ "(PicHandle pic) -> None"},
+ {"GetWindowPic", (PyCFunction)WinObj_GetWindowPic, 1,
+ "() -> (PicHandle _rv)"},
+ {"GetWVariant", (PyCFunction)WinObj_GetWVariant, 1,
+ "() -> (short _rv)"},
+ {"GetWindowFeatures", (PyCFunction)WinObj_GetWindowFeatures, 1,
+ "() -> (UInt32 outFeatures)"},
+ {"GetWindowRegion", (PyCFunction)WinObj_GetWindowRegion, 1,
+ "(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> None"},
+ {"BeginUpdate", (PyCFunction)WinObj_BeginUpdate, 1,
+ "() -> None"},
+ {"EndUpdate", (PyCFunction)WinObj_EndUpdate, 1,
+ "() -> None"},
+ {"InvalWindowRgn", (PyCFunction)WinObj_InvalWindowRgn, 1,
+ "(RgnHandle region) -> None"},
+ {"InvalWindowRect", (PyCFunction)WinObj_InvalWindowRect, 1,
+ "(Rect bounds) -> None"},
+ {"ValidWindowRgn", (PyCFunction)WinObj_ValidWindowRgn, 1,
+ "(RgnHandle region) -> None"},
+ {"ValidWindowRect", (PyCFunction)WinObj_ValidWindowRect, 1,
+ "(Rect bounds) -> None"},
+ {"DrawGrowIcon", (PyCFunction)WinObj_DrawGrowIcon, 1,
+ "() -> None"},
+ {"SetWTitle", (PyCFunction)WinObj_SetWTitle, 1,
+ "(Str255 title) -> None"},
+ {"GetWTitle", (PyCFunction)WinObj_GetWTitle, 1,
+ "() -> (Str255 title)"},
+ {"SetWindowProxyFSSpec", (PyCFunction)WinObj_SetWindowProxyFSSpec, 1,
+ "(FSSpec inFile) -> None"},
+ {"GetWindowProxyFSSpec", (PyCFunction)WinObj_GetWindowProxyFSSpec, 1,
+ "() -> (FSSpec outFile)"},
+ {"SetWindowProxyAlias", (PyCFunction)WinObj_SetWindowProxyAlias, 1,
+ "(AliasHandle alias) -> None"},
+ {"GetWindowProxyAlias", (PyCFunction)WinObj_GetWindowProxyAlias, 1,
+ "() -> (AliasHandle alias)"},
+ {"SetWindowProxyCreatorAndType", (PyCFunction)WinObj_SetWindowProxyCreatorAndType, 1,
+ "(OSType fileCreator, OSType fileType, SInt16 vRefNum) -> None"},
+ {"GetWindowProxyIcon", (PyCFunction)WinObj_GetWindowProxyIcon, 1,
+ "() -> (IconRef outIcon)"},
+ {"SetWindowProxyIcon", (PyCFunction)WinObj_SetWindowProxyIcon, 1,
+ "(IconRef icon) -> None"},
+ {"RemoveWindowProxy", (PyCFunction)WinObj_RemoveWindowProxy, 1,
+ "() -> None"},
+ {"BeginWindowProxyDrag", (PyCFunction)WinObj_BeginWindowProxyDrag, 1,
+ "(RgnHandle outDragOutlineRgn) -> (DragReference outNewDrag)"},
+ {"EndWindowProxyDrag", (PyCFunction)WinObj_EndWindowProxyDrag, 1,
+ "(DragReference theDrag) -> None"},
+ {"TrackWindowProxyFromExistingDrag", (PyCFunction)WinObj_TrackWindowProxyFromExistingDrag, 1,
+ "(Point startPt, DragReference drag, RgnHandle inDragOutlineRgn) -> None"},
+ {"TrackWindowProxyDrag", (PyCFunction)WinObj_TrackWindowProxyDrag, 1,
+ "(Point startPt) -> None"},
+ {"IsWindowModified", (PyCFunction)WinObj_IsWindowModified, 1,
+ "() -> (Boolean _rv)"},
+ {"SetWindowModified", (PyCFunction)WinObj_SetWindowModified, 1,
+ "(Boolean modified) -> None"},
+ {"IsWindowPathSelectClick", (PyCFunction)WinObj_IsWindowPathSelectClick, 1,
+ "(EventRecord event) -> (Boolean _rv)"},
+ {"WindowPathSelect", (PyCFunction)WinObj_WindowPathSelect, 1,
+ "(MenuHandle menu) -> (SInt32 outMenuResult)"},
+ {"HiliteWindowFrameForDrag", (PyCFunction)WinObj_HiliteWindowFrameForDrag, 1,
+ "(Boolean hilited) -> None"},
+ {"TransitionWindow", (PyCFunction)WinObj_TransitionWindow, 1,
+ "(WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None"},
+ {"MacMoveWindow", (PyCFunction)WinObj_MacMoveWindow, 1,
+ "(short hGlobal, short vGlobal, Boolean front) -> None"},
+ {"SizeWindow", (PyCFunction)WinObj_SizeWindow, 1,
+ "(short w, short h, Boolean fUpdate) -> None"},
+ {"GrowWindow", (PyCFunction)WinObj_GrowWindow, 1,
+ "(Point startPt, Rect bBox) -> (long _rv)"},
+ {"DragWindow", (PyCFunction)WinObj_DragWindow, 1,
+ "(Point startPt, Rect boundsRect) -> None"},
+ {"ZoomWindow", (PyCFunction)WinObj_ZoomWindow, 1,
+ "(WindowPartCode partCode, Boolean front) -> None"},
+ {"IsWindowCollapsable", (PyCFunction)WinObj_IsWindowCollapsable, 1,
+ "() -> (Boolean _rv)"},
+ {"IsWindowCollapsed", (PyCFunction)WinObj_IsWindowCollapsed, 1,
+ "() -> (Boolean _rv)"},
+ {"CollapseWindow", (PyCFunction)WinObj_CollapseWindow, 1,
+ "(Boolean collapse) -> None"},
+ {"GetWindowBounds", (PyCFunction)WinObj_GetWindowBounds, 1,
+ "(WindowRegionCode regionCode) -> (Rect globalBounds)"},
+ {"ResizeWindow", (PyCFunction)WinObj_ResizeWindow, 1,
+ "(Point startPoint, Rect sizeConstraints) -> (Boolean _rv, Rect newContentRect)"},
+ {"SetWindowBounds", (PyCFunction)WinObj_SetWindowBounds, 1,
+ "(WindowRegionCode regionCode, Rect globalBounds) -> None"},
+ {"RepositionWindow", (PyCFunction)WinObj_RepositionWindow, 1,
+ "(WindowPtr parentWindow, WindowPositionMethod method) -> None"},
+ {"MoveWindowStructure", (PyCFunction)WinObj_MoveWindowStructure, 1,
+ "(short hGlobal, short vGlobal) -> None"},
+ {"IsWindowInStandardState", (PyCFunction)WinObj_IsWindowInStandardState, 1,
+ "() -> (Boolean _rv, Point idealSize, Rect idealStandardState)"},
+ {"ZoomWindowIdeal", (PyCFunction)WinObj_ZoomWindowIdeal, 1,
+ "(WindowPartCode partCode) -> (Point ioIdealSize)"},
+ {"GetWindowIdealUserState", (PyCFunction)WinObj_GetWindowIdealUserState, 1,
+ "() -> (Rect userState)"},
+ {"SetWindowIdealUserState", (PyCFunction)WinObj_SetWindowIdealUserState, 1,
+ "() -> (Rect userState)"},
+ {"HideWindow", (PyCFunction)WinObj_HideWindow, 1,
+ "() -> None"},
+ {"MacShowWindow", (PyCFunction)WinObj_MacShowWindow, 1,
+ "() -> None"},
+ {"ShowHide", (PyCFunction)WinObj_ShowHide, 1,
+ "(Boolean showFlag) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"GetWindowPropertyAttributes", (PyCFunction)WinObj_GetWindowPropertyAttributes, 1,
+ "(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"ChangeWindowPropertyAttributes", (PyCFunction)WinObj_ChangeWindowPropertyAttributes, 1,
+ "(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"},
+#endif
+ {"TrackBox", (PyCFunction)WinObj_TrackBox, 1,
+ "(Point thePt, WindowPartCode partCode) -> (Boolean _rv)"},
+ {"TrackGoAway", (PyCFunction)WinObj_TrackGoAway, 1,
+ "(Point thePt) -> (Boolean _rv)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"GetAuxWin", (PyCFunction)WinObj_GetAuxWin, 1,
+ "() -> (Boolean _rv, AuxWinHandle awHndl)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"GetWindowGoAwayFlag", (PyCFunction)WinObj_GetWindowGoAwayFlag, 1,
+ "() -> (Boolean _rv)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"GetWindowSpareFlag", (PyCFunction)WinObj_GetWindowSpareFlag, 1,
+ "() -> (Boolean _rv)"},
+#endif
+ {"GetWindowPort", (PyCFunction)WinObj_GetWindowPort, 1,
+ "() -> (CGrafPtr _rv)"},
+ {"GetWindowKind", (PyCFunction)WinObj_GetWindowKind, 1,
+ "() -> (short _rv)"},
+ {"MacIsWindowVisible", (PyCFunction)WinObj_MacIsWindowVisible, 1,
+ "() -> (Boolean _rv)"},
+ {"IsWindowHilited", (PyCFunction)WinObj_IsWindowHilited, 1,
+ "() -> (Boolean _rv)"},
+
+#if TARGET_API_MAC_CARBON
+ {"IsWindowUpdatePending", (PyCFunction)WinObj_IsWindowUpdatePending, 1,
+ "() -> (Boolean _rv)"},
+#endif
+ {"MacGetNextWindow", (PyCFunction)WinObj_MacGetNextWindow, 1,
+ "() -> (WindowPtr _rv)"},
+ {"GetWindowStandardState", (PyCFunction)WinObj_GetWindowStandardState, 1,
+ "() -> (Rect rect)"},
+ {"GetWindowUserState", (PyCFunction)WinObj_GetWindowUserState, 1,
+ "() -> (Rect rect)"},
+ {"SetWindowKind", (PyCFunction)WinObj_SetWindowKind, 1,
+ "(short kind) -> None"},
+ {"SetWindowStandardState", (PyCFunction)WinObj_SetWindowStandardState, 1,
+ "(Rect rect) -> None"},
+ {"SetWindowUserState", (PyCFunction)WinObj_SetWindowUserState, 1,
+ "(Rect rect) -> None"},
+ {"SetPortWindowPort", (PyCFunction)WinObj_SetPortWindowPort, 1,
+ "() -> None"},
+ {"GetWindowPortBounds", (PyCFunction)WinObj_GetWindowPortBounds, 1,
+ "() -> (Rect bounds)"},
+ {"IsWindowVisible", (PyCFunction)WinObj_IsWindowVisible, 1,
+ "() -> (Boolean _rv)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"GetWindowZoomFlag", (PyCFunction)WinObj_GetWindowZoomFlag, 1,
+ "() -> (Boolean _rv)"},
+#endif
+ {"GetWindowStructureRgn", (PyCFunction)WinObj_GetWindowStructureRgn, 1,
+ "(RgnHandle r) -> None"},
+ {"GetWindowContentRgn", (PyCFunction)WinObj_GetWindowContentRgn, 1,
+ "(RgnHandle r) -> None"},
+ {"GetWindowUpdateRgn", (PyCFunction)WinObj_GetWindowUpdateRgn, 1,
+ "(RgnHandle r) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+ {"GetWindowTitleWidth", (PyCFunction)WinObj_GetWindowTitleWidth, 1,
+ "() -> (short _rv)"},
+#endif
+ {"GetNextWindow", (PyCFunction)WinObj_GetNextWindow, 1,
+ "() -> (WindowPtr _rv)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"CloseWindow", (PyCFunction)WinObj_CloseWindow, 1,
+ "() -> None"},
+#endif
+ {"MoveWindow", (PyCFunction)WinObj_MoveWindow, 1,
+ "(short hGlobal, short vGlobal, Boolean front) -> None"},
+ {"ShowWindow", (PyCFunction)WinObj_ShowWindow, 1,
+ "() -> None"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain WinObj_chain = { WinObj_methods, NULL };
+
+static PyObject *WinObj_getattr(WindowObject *self, char *name)
+{
+ return Py_FindMethodInChain(&WinObj_chain, (PyObject *)self, name);
+}
+
+#define WinObj_setattr NULL
+
+static int WinObj_compare(WindowObject *self, WindowObject *other)
+{
+ if ( self->ob_itself > other->ob_itself ) return 1;
+ if ( self->ob_itself < other->ob_itself ) return -1;
+ return 0;
+}
+
+static PyObject * WinObj_repr(WindowObject *self)
+{
+ char buf[100];
+ sprintf(buf, "<Window object at 0x%08.8x for 0x%08.8x>", self, self->ob_itself);
+ return PyString_FromString(buf);
+}
+
+static int WinObj_hash(WindowObject *self)
+{
+ return (int)self->ob_itself;
+}
+
+PyTypeObject Window_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "Window", /*tp_name*/
+ sizeof(WindowObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) WinObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) WinObj_getattr, /*tp_getattr*/
+ (setattrfunc) WinObj_setattr, /*tp_setattr*/
+ (cmpfunc) WinObj_compare, /*tp_compare*/
+ (reprfunc) WinObj_repr, /*tp_repr*/
+ (PyNumberMethods *)0, /* tp_as_number */
+ (PySequenceMethods *)0, /* tp_as_sequence */
+ (PyMappingMethods *)0, /* tp_as_mapping */
+ (hashfunc) WinObj_hash, /*tp_hash*/
+};
+
+/* --------------------- End object type Window --------------------- */
+
+
+static PyObject *Win_GetNewCWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ short windowID;
+ WindowPtr behind;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &windowID,
+ WinObj_Convert, &behind))
+ return NULL;
+ _rv = GetNewCWindow(windowID,
+ (void *)0,
+ behind);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Win_NewWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ Rect boundsRect;
+ Str255 title;
+ Boolean visible;
+ short theProc;
+ WindowPtr behind;
+ Boolean goAwayFlag;
+ long refCon;
+ if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
+ PyMac_GetRect, &boundsRect,
+ PyMac_GetStr255, title,
+ &visible,
+ &theProc,
+ WinObj_Convert, &behind,
+ &goAwayFlag,
+ &refCon))
+ return NULL;
+ _rv = NewWindow((void *)0,
+ &boundsRect,
+ title,
+ visible,
+ theProc,
+ behind,
+ goAwayFlag,
+ refCon);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Win_GetNewWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ short windowID;
+ WindowPtr behind;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &windowID,
+ WinObj_Convert, &behind))
+ return NULL;
+ _rv = GetNewWindow(windowID,
+ (void *)0,
+ behind);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Win_NewCWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ Rect boundsRect;
+ Str255 title;
+ Boolean visible;
+ short procID;
+ WindowPtr behind;
+ Boolean goAwayFlag;
+ long refCon;
+ if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
+ PyMac_GetRect, &boundsRect,
+ PyMac_GetStr255, title,
+ &visible,
+ &procID,
+ WinObj_Convert, &behind,
+ &goAwayFlag,
+ &refCon))
+ return NULL;
+ _rv = NewCWindow((void *)0,
+ &boundsRect,
+ title,
+ visible,
+ procID,
+ behind,
+ goAwayFlag,
+ refCon);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Win_CreateNewWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ WindowClass windowClass;
+ WindowAttributes attributes;
+ Rect contentBounds;
+ WindowPtr outWindow;
+ if (!PyArg_ParseTuple(_args, "llO&",
+ &windowClass,
+ &attributes,
+ PyMac_GetRect, &contentBounds))
+ return NULL;
+ _err = CreateNewWindow(windowClass,
+ attributes,
+ &contentBounds,
+ &outWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ WinObj_WhichWindow, outWindow);
+ return _res;
+}
+
+static PyObject *Win_CreateWindowFromResource(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ SInt16 resID;
+ WindowPtr outWindow;
+ if (!PyArg_ParseTuple(_args, "h",
+ &resID))
+ return NULL;
+ _err = CreateWindowFromResource(resID,
+ &outWindow);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ WinObj_WhichWindow, outWindow);
+ return _res;
+}
+
+static PyObject *Win_ShowFloatingWindows(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = ShowFloatingWindows();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Win_HideFloatingWindows(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = HideFloatingWindows();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Win_AreFloatingWindowsVisible(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = AreFloatingWindowsVisible();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Win_SetDeskCPat(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ PixPatHandle deskPixPat;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &deskPixPat))
+ return NULL;
+ SetDeskCPat(deskPixPat);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Win_CheckUpdate(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventRecord theEvent;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CheckUpdate(&theEvent);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildEventRecord, &theEvent);
+ return _res;
+}
+
+static PyObject *Win_MacFindWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPartCode _rv;
+ Point thePoint;
+ WindowPtr window;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &thePoint))
+ return NULL;
+ _rv = MacFindWindow(thePoint,
+ &window);
+ _res = Py_BuildValue("hO&",
+ _rv,
+ WinObj_WhichWindow, window);
+ return _res;
+}
+
+static PyObject *Win_FrontWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = FrontWindow();
+ _res = Py_BuildValue("O&",
+ WinObj_WhichWindow, _rv);
+ return _res;
+}
+
+static PyObject *Win_FrontNonFloatingWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = FrontNonFloatingWindow();
+ _res = Py_BuildValue("O&",
+ WinObj_WhichWindow, _rv);
+ return _res;
+}
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Win_GetFrontWindowOfClass(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ WindowClass inWindowClass;
+ Boolean mustBeVisible;
+ if (!PyArg_ParseTuple(_args, "lb",
+ &inWindowClass,
+ &mustBeVisible))
+ return NULL;
+ _rv = GetFrontWindowOfClass(inWindowClass,
+ mustBeVisible);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Win_FindWindowOfClass(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Point where;
+ WindowClass inWindowClass;
+ WindowPtr outWindow;
+ WindowPartCode outWindowPart;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ PyMac_GetPoint, &where,
+ &inWindowClass))
+ return NULL;
+ _err = FindWindowOfClass(&where,
+ inWindowClass,
+ &outWindow,
+ &outWindowPart);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&h",
+ WinObj_WhichWindow, outWindow,
+ outWindowPart);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Win_InitWindows(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ InitWindows();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Win_GetWMgrPort(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ GrafPtr wPort;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetWMgrPort(&wPort);
+ _res = Py_BuildValue("O&",
+ GrafObj_New, wPort);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Win_GetCWMgrPort(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CGrafPtr wMgrCPort;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetCWMgrPort(&wMgrCPort);
+ _res = Py_BuildValue("O&",
+ GrafObj_New, wMgrCPort);
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Win_InitFloatingWindows(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = InitFloatingWindows();
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Win_InvalRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect badRect;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &badRect))
+ return NULL;
+ InvalRect(&badRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Win_InvalRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle badRgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &badRgn))
+ return NULL;
+ InvalRgn(badRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Win_ValidRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Rect goodRect;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &goodRect))
+ return NULL;
+ ValidRect(&goodRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Win_ValidRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle goodRgn;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &goodRgn))
+ return NULL;
+ ValidRgn(goodRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+static PyObject *Win_CollapseAllWindows(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ Boolean collapse;
+ if (!PyArg_ParseTuple(_args, "b",
+ &collapse))
+ return NULL;
+ _err = CollapseAllWindows(collapse);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Win_PinRect(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ long _rv;
+ Rect theRect;
+ Point thePt;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &theRect,
+ PyMac_GetPoint, &thePt))
+ return NULL;
+ _rv = PinRect(&theRect,
+ thePt);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Win_GetGrayRgn(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ RgnHandle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetGrayRgn();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Win_GetWindowFromPort(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ CGrafPtr port;
+ if (!PyArg_ParseTuple(_args, "O&",
+ GrafObj_Convert, &port))
+ return NULL;
+ _rv = GetWindowFromPort(port);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Win_WhichWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ long ptr;
+
+ if ( !PyArg_ParseTuple(_args, "i", &ptr) )
+ return NULL;
+ return WinObj_WhichWindow((WindowPtr)ptr);
+
+}
+
+static PyObject *Win_FindWindow(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short _rv;
+ Point thePoint;
+ WindowPtr theWindow;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &thePoint))
+ return NULL;
+ _rv = FindWindow(thePoint,
+ &theWindow);
+ _res = Py_BuildValue("hO&",
+ _rv,
+ WinObj_WhichWindow, theWindow);
+ return _res;
+}
+
+static PyMethodDef Win_methods[] = {
+ {"GetNewCWindow", (PyCFunction)Win_GetNewCWindow, 1,
+ "(short windowID, WindowPtr behind) -> (WindowPtr _rv)"},
+ {"NewWindow", (PyCFunction)Win_NewWindow, 1,
+ "(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"},
+ {"GetNewWindow", (PyCFunction)Win_GetNewWindow, 1,
+ "(short windowID, WindowPtr behind) -> (WindowPtr _rv)"},
+ {"NewCWindow", (PyCFunction)Win_NewCWindow, 1,
+ "(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"},
+ {"CreateNewWindow", (PyCFunction)Win_CreateNewWindow, 1,
+ "(WindowClass windowClass, WindowAttributes attributes, Rect contentBounds) -> (WindowPtr outWindow)"},
+ {"CreateWindowFromResource", (PyCFunction)Win_CreateWindowFromResource, 1,
+ "(SInt16 resID) -> (WindowPtr outWindow)"},
+ {"ShowFloatingWindows", (PyCFunction)Win_ShowFloatingWindows, 1,
+ "() -> None"},
+ {"HideFloatingWindows", (PyCFunction)Win_HideFloatingWindows, 1,
+ "() -> None"},
+ {"AreFloatingWindowsVisible", (PyCFunction)Win_AreFloatingWindowsVisible, 1,
+ "() -> (Boolean _rv)"},
+
+#if !TARGET_API_MAC_CARBON
+ {"SetDeskCPat", (PyCFunction)Win_SetDeskCPat, 1,
+ "(PixPatHandle deskPixPat) -> None"},
+#endif
+ {"CheckUpdate", (PyCFunction)Win_CheckUpdate, 1,
+ "() -> (Boolean _rv, EventRecord theEvent)"},
+ {"MacFindWindow", (PyCFunction)Win_MacFindWindow, 1,
+ "(Point thePoint) -> (WindowPartCode _rv, WindowPtr window)"},
+ {"FrontWindow", (PyCFunction)Win_FrontWindow, 1,
+ "() -> (WindowPtr _rv)"},
+ {"FrontNonFloatingWindow", (PyCFunction)Win_FrontNonFloatingWindow, 1,
+ "() -> (WindowPtr _rv)"},
+
+#if TARGET_API_MAC_CARBON
+ {"GetFrontWindowOfClass", (PyCFunction)Win_GetFrontWindowOfClass, 1,
+ "(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"FindWindowOfClass", (PyCFunction)Win_FindWindowOfClass, 1,
+ "(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"InitWindows", (PyCFunction)Win_InitWindows, 1,
+ "() -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"GetWMgrPort", (PyCFunction)Win_GetWMgrPort, 1,
+ "() -> (GrafPtr wPort)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"GetCWMgrPort", (PyCFunction)Win_GetCWMgrPort, 1,
+ "() -> (CGrafPtr wMgrCPort)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"InitFloatingWindows", (PyCFunction)Win_InitFloatingWindows, 1,
+ "() -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"InvalRect", (PyCFunction)Win_InvalRect, 1,
+ "(Rect badRect) -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"InvalRgn", (PyCFunction)Win_InvalRgn, 1,
+ "(RgnHandle badRgn) -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"ValidRect", (PyCFunction)Win_ValidRect, 1,
+ "(Rect goodRect) -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+ {"ValidRgn", (PyCFunction)Win_ValidRgn, 1,
+ "(RgnHandle goodRgn) -> None"},
+#endif
+ {"CollapseAllWindows", (PyCFunction)Win_CollapseAllWindows, 1,
+ "(Boolean collapse) -> None"},
+ {"PinRect", (PyCFunction)Win_PinRect, 1,
+ "(Rect theRect, Point thePt) -> (long _rv)"},
+ {"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1,
+ "() -> (RgnHandle _rv)"},
+ {"GetWindowFromPort", (PyCFunction)Win_GetWindowFromPort, 1,
+ "(CGrafPtr port) -> (WindowPtr _rv)"},
+ {"WhichWindow", (PyCFunction)Win_WhichWindow, 1,
+ "Resolve an integer WindowPtr address to a Window object"},
+ {"FindWindow", (PyCFunction)Win_FindWindow, 1,
+ "(Point thePoint) -> (short _rv, WindowPtr theWindow)"},
+ {NULL, NULL, 0}
+};
+
+
+
+/* Return the object corresponding to the window, or NULL */
+
+PyObject *
+WinObj_WhichWindow(WindowPtr w)
+{
+ PyObject *it;
+
+ if (w == NULL) {
+ it = Py_None;
+ Py_INCREF(it);
+ } else {
+ it = (PyObject *) GetWRefCon(w);
+ if (it == NULL || !IsPointerValid((Ptr)it) || ((WindowObject *)it)->ob_itself != w || !WinObj_Check(it)) {
+ it = WinObj_New(w);
+ ((WindowObject *)it)->ob_freeit = NULL;
+ } else {
+ Py_INCREF(it);
+ }
+ }
+ return it;
+}
+
+
+void init_Win(void)
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(WindowPtr, WinObj_New);
+ PyMac_INIT_TOOLBOX_OBJECT_NEW(WindowPtr, WinObj_WhichWindow);
+ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(WindowPtr, WinObj_Convert);
+
+
+ m = Py_InitModule("_Win", Win_methods);
+ d = PyModule_GetDict(m);
+ Win_Error = PyMac_GetOSErrException();
+ if (Win_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Win_Error) != 0)
+ return;
+ Window_Type.ob_type = &PyType_Type;
+ Py_INCREF(&Window_Type);
+ if (PyDict_SetItemString(d, "WindowType", (PyObject *)&Window_Type) != 0)
+ Py_FatalError("can't initialize WindowType");
+}
+
+/* ======================== End module _Win ========================= */
+
projects / python / commitdiff