/* =========================== Module _Cm =========================== */ #include "Python.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 <Carbon/Carbon.h> #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 || PyObject_TypeCheck((x), &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; } int 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 */ self->ob_type->tp_free((PyObject *)self); } static PyObject *CmpInstObj_CloseComponent(ComponentInstanceObject *_self, PyObject *_args) { PyObject *_res = NULL; OSErr _err; #ifndef CloseComponent PyMac_PRECHECK(CloseComponent); #endif 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; #ifndef GetComponentInstanceError PyMac_PRECHECK(GetComponentInstanceError); #endif 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; #ifndef SetComponentInstanceError PyMac_PRECHECK(SetComponentInstanceError); #endif 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; #ifndef GetComponentInstanceStorage PyMac_PRECHECK(GetComponentInstanceStorage); #endif 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; #ifndef SetComponentInstanceStorage PyMac_PRECHECK(SetComponentInstanceStorage); #endif if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &theStorage)) return NULL; SetComponentInstanceStorage(_self->ob_itself, theStorage); Py_INCREF(Py_None); _res = Py_None; return _res; } #ifndef __LP64__ static PyObject *CmpInstObj_ComponentFunctionImplemented(ComponentInstanceObject *_self, PyObject *_args) { PyObject *_res = NULL; long _rv; short ftnNumber; #ifndef ComponentFunctionImplemented PyMac_PRECHECK(ComponentFunctionImplemented); #endif 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; #ifndef GetComponentVersion PyMac_PRECHECK(GetComponentVersion); #endif 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; #ifndef ComponentSetTarget PyMac_PRECHECK(ComponentSetTarget); #endif if (!PyArg_ParseTuple(_args, "O&", CmpInstObj_Convert, &target)) return NULL; _rv = ComponentSetTarget(_self->ob_itself, target); _res = Py_BuildValue("l", _rv); return _res; } #endif /* !__LP64__*/ static PyMethodDef CmpInstObj_methods[] = { {"CloseComponent", (PyCFunction)CmpInstObj_CloseComponent, 1, PyDoc_STR("() -> None")}, {"GetComponentInstanceError", (PyCFunction)CmpInstObj_GetComponentInstanceError, 1, PyDoc_STR("() -> None")}, {"SetComponentInstanceError", (PyCFunction)CmpInstObj_SetComponentInstanceError, 1, PyDoc_STR("(OSErr theError) -> None")}, {"GetComponentInstanceStorage", (PyCFunction)CmpInstObj_GetComponentInstanceStorage, 1, PyDoc_STR("() -> (Handle _rv)")}, {"SetComponentInstanceStorage", (PyCFunction)CmpInstObj_SetComponentInstanceStorage, 1, PyDoc_STR("(Handle theStorage) -> None")}, #ifndef __LP64__ {"ComponentFunctionImplemented", (PyCFunction)CmpInstObj_ComponentFunctionImplemented, 1, PyDoc_STR("(short ftnNumber) -> (long _rv)")}, {"GetComponentVersion", (PyCFunction)CmpInstObj_GetComponentVersion, 1, PyDoc_STR("() -> (long _rv)")}, {"ComponentSetTarget", (PyCFunction)CmpInstObj_ComponentSetTarget, 1, PyDoc_STR("(ComponentInstance target) -> (long _rv)")}, #endif /* !__LP64__ */ {NULL, NULL, 0} }; #define CmpInstObj_getsetlist NULL #define CmpInstObj_compare NULL #define CmpInstObj_repr NULL #define CmpInstObj_hash NULL #define CmpInstObj_tp_init 0 #define CmpInstObj_tp_alloc PyType_GenericAlloc static PyObject *CmpInstObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) { PyObject *_self; ComponentInstance itself; char *kw[] = {"itself", 0}; if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CmpInstObj_Convert, &itself)) return NULL; if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; ((ComponentInstanceObject *)_self)->ob_itself = itself; return _self; } #define CmpInstObj_tp_free PyObject_Del PyTypeObject ComponentInstance_Type = { PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ "_Cm.ComponentInstance", /*tp_name*/ sizeof(ComponentInstanceObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor) CmpInstObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ (getattrfunc)0, /*tp_getattr*/ (setattrfunc)0, /*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*/ 0, /*tp_call*/ 0, /*tp_str*/ PyObject_GenericGetAttr, /*tp_getattro*/ PyObject_GenericSetAttr, /*tp_setattro */ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ 0, /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ CmpInstObj_methods, /* tp_methods */ 0, /*tp_members*/ CmpInstObj_getsetlist, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ CmpInstObj_tp_init, /* tp_init */ CmpInstObj_tp_alloc, /* tp_alloc */ CmpInstObj_tp_new, /* tp_new */ CmpInstObj_tp_free, /* tp_free */ }; /* --------------- End object type ComponentInstance ---------------- */ /* --------------------- Object type Component ---------------------- */ PyTypeObject Component_Type; #define CmpObj_Check(x) ((x)->ob_type == &Component_Type || PyObject_TypeCheck((x), &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; } int 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 */ self->ob_type->tp_free((PyObject *)self); } static PyObject *CmpObj_UnregisterComponent(ComponentObject *_self, PyObject *_args) { PyObject *_res = NULL; OSErr _err; #ifndef UnregisterComponent PyMac_PRECHECK(UnregisterComponent); #endif 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; #ifndef GetComponentInfo PyMac_PRECHECK(GetComponentInfo); #endif 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; #ifndef OpenComponent PyMac_PRECHECK(OpenComponent); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = OpenComponent(_self->ob_itself); _res = Py_BuildValue("O&", CmpInstObj_New, _rv); return _res; } static PyObject *CmpObj_ResolveComponentAlias(ComponentObject *_self, PyObject *_args) { PyObject *_res = NULL; Component _rv; #ifndef ResolveComponentAlias PyMac_PRECHECK(ResolveComponentAlias); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = ResolveComponentAlias(_self->ob_itself); _res = Py_BuildValue("O&", CmpObj_New, _rv); return _res; } static PyObject *CmpObj_GetComponentPublicIndString(ComponentObject *_self, PyObject *_args) { PyObject *_res = NULL; OSErr _err; Str255 theString; short strListID; short index; #ifndef GetComponentPublicIndString PyMac_PRECHECK(GetComponentPublicIndString); #endif if (!PyArg_ParseTuple(_args, "O&hh", PyMac_GetStr255, theString, &strListID, &index)) return NULL; _err = GetComponentPublicIndString(_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_GetComponentRefcon(ComponentObject *_self, PyObject *_args) { PyObject *_res = NULL; long _rv; #ifndef GetComponentRefcon PyMac_PRECHECK(GetComponentRefcon); #endif 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; #ifndef SetComponentRefcon PyMac_PRECHECK(SetComponentRefcon); #endif 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; #ifndef OpenComponentResFile PyMac_PRECHECK(OpenComponentResFile); #endif 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; #ifndef GetComponentResource PyMac_PRECHECK(GetComponentResource); #endif 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; #ifndef GetComponentIndString PyMac_PRECHECK(GetComponentIndString); #endif 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_CountComponentInstances(ComponentObject *_self, PyObject *_args) { PyObject *_res = NULL; long _rv; #ifndef CountComponentInstances PyMac_PRECHECK(CountComponentInstances); #endif 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; #ifndef SetDefaultComponent PyMac_PRECHECK(SetDefaultComponent); #endif 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; #ifndef CaptureComponent PyMac_PRECHECK(CaptureComponent); #endif 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; #ifndef UncaptureComponent PyMac_PRECHECK(UncaptureComponent); #endif 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; } #ifndef __LP64__ static PyObject *CmpObj_GetComponentIconSuite(ComponentObject *_self, PyObject *_args) { PyObject *_res = NULL; OSErr _err; Handle iconSuite; #ifndef GetComponentIconSuite PyMac_PRECHECK(GetComponentIconSuite); #endif 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; } #endif /* !__LP64__ */ static PyMethodDef CmpObj_methods[] = { {"UnregisterComponent", (PyCFunction)CmpObj_UnregisterComponent, 1, PyDoc_STR("() -> None")}, {"GetComponentInfo", (PyCFunction)CmpObj_GetComponentInfo, 1, PyDoc_STR("(Handle componentName, Handle componentInfo, Handle componentIcon) -> (ComponentDescription cd)")}, {"OpenComponent", (PyCFunction)CmpObj_OpenComponent, 1, PyDoc_STR("() -> (ComponentInstance _rv)")}, {"ResolveComponentAlias", (PyCFunction)CmpObj_ResolveComponentAlias, 1, PyDoc_STR("() -> (Component _rv)")}, {"GetComponentPublicIndString", (PyCFunction)CmpObj_GetComponentPublicIndString, 1, PyDoc_STR("(Str255 theString, short strListID, short index) -> None")}, {"GetComponentRefcon", (PyCFunction)CmpObj_GetComponentRefcon, 1, PyDoc_STR("() -> (long _rv)")}, {"SetComponentRefcon", (PyCFunction)CmpObj_SetComponentRefcon, 1, PyDoc_STR("(long theRefcon) -> None")}, {"OpenComponentResFile", (PyCFunction)CmpObj_OpenComponentResFile, 1, PyDoc_STR("() -> (short _rv)")}, {"GetComponentResource", (PyCFunction)CmpObj_GetComponentResource, 1, PyDoc_STR("(OSType resType, short resID) -> (Handle theResource)")}, {"GetComponentIndString", (PyCFunction)CmpObj_GetComponentIndString, 1, PyDoc_STR("(Str255 theString, short strListID, short index) -> None")}, {"CountComponentInstances", (PyCFunction)CmpObj_CountComponentInstances, 1, PyDoc_STR("() -> (long _rv)")}, {"SetDefaultComponent", (PyCFunction)CmpObj_SetDefaultComponent, 1, PyDoc_STR("(short flags) -> None")}, {"CaptureComponent", (PyCFunction)CmpObj_CaptureComponent, 1, PyDoc_STR("(Component capturingComponent) -> (Component _rv)")}, {"UncaptureComponent", (PyCFunction)CmpObj_UncaptureComponent, 1, PyDoc_STR("() -> None")}, #ifndef __LP64__ {"GetComponentIconSuite", (PyCFunction)CmpObj_GetComponentIconSuite, 1, PyDoc_STR("() -> (Handle iconSuite)")}, #endif /* !__LP64__ */ {NULL, NULL, 0} }; #define CmpObj_getsetlist NULL #define CmpObj_compare NULL #define CmpObj_repr NULL #define CmpObj_hash NULL #define CmpObj_tp_init 0 #define CmpObj_tp_alloc PyType_GenericAlloc static PyObject *CmpObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) { PyObject *_self; Component itself; char *kw[] = {"itself", 0}; if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CmpObj_Convert, &itself)) return NULL; if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; ((ComponentObject *)_self)->ob_itself = itself; return _self; } #define CmpObj_tp_free PyObject_Del PyTypeObject Component_Type = { PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ "_Cm.Component", /*tp_name*/ sizeof(ComponentObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor) CmpObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ (getattrfunc)0, /*tp_getattr*/ (setattrfunc)0, /*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*/ 0, /*tp_call*/ 0, /*tp_str*/ PyObject_GenericGetAttr, /*tp_getattro*/ PyObject_GenericSetAttr, /*tp_setattro */ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ 0, /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ CmpObj_methods, /* tp_methods */ 0, /*tp_members*/ CmpObj_getsetlist, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ CmpObj_tp_init, /* tp_init */ CmpObj_tp_alloc, /* tp_alloc */ CmpObj_tp_new, /* tp_new */ CmpObj_tp_free, /* tp_free */ }; /* ------------------- End object type Component -------------------- */ static PyObject *Cm_RegisterComponentResource(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; Component _rv; ComponentResourceHandle cr; short global; #ifndef RegisterComponentResource PyMac_PRECHECK(RegisterComponentResource); #endif 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; #ifndef FindNextComponent PyMac_PRECHECK(FindNextComponent); #endif 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; #ifndef CountComponents PyMac_PRECHECK(CountComponents); #endif 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; #ifndef GetComponentListModSeed PyMac_PRECHECK(GetComponentListModSeed); #endif 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; #ifndef CloseComponentResFile PyMac_PRECHECK(CloseComponentResFile); #endif 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; #ifndef OpenDefaultComponent PyMac_PRECHECK(OpenDefaultComponent); #endif 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; #ifndef RegisterComponentResourceFile PyMac_PRECHECK(RegisterComponentResourceFile); #endif 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, PyDoc_STR("(ComponentResourceHandle cr, short global) -> (Component _rv)")}, {"FindNextComponent", (PyCFunction)Cm_FindNextComponent, 1, PyDoc_STR("(Component aComponent, ComponentDescription looking) -> (Component _rv)")}, {"CountComponents", (PyCFunction)Cm_CountComponents, 1, PyDoc_STR("(ComponentDescription looking) -> (long _rv)")}, {"GetComponentListModSeed", (PyCFunction)Cm_GetComponentListModSeed, 1, PyDoc_STR("() -> (long _rv)")}, {"CloseComponentResFile", (PyCFunction)Cm_CloseComponentResFile, 1, PyDoc_STR("(short refnum) -> None")}, {"OpenDefaultComponent", (PyCFunction)Cm_OpenDefaultComponent, 1, PyDoc_STR("(OSType componentType, OSType componentSubType) -> (ComponentInstance _rv)")}, {"RegisterComponentResourceFile", (PyCFunction)Cm_RegisterComponentResourceFile, 1, PyDoc_STR("(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; if (PyType_Ready(&ComponentInstance_Type) < 0) return; Py_INCREF(&ComponentInstance_Type); PyModule_AddObject(m, "ComponentInstance", (PyObject *)&ComponentInstance_Type); /* Backward-compatible name */ Py_INCREF(&ComponentInstance_Type); PyModule_AddObject(m, "ComponentInstanceType", (PyObject *)&ComponentInstance_Type); Component_Type.ob_type = &PyType_Type; if (PyType_Ready(&Component_Type) < 0) return; Py_INCREF(&Component_Type); PyModule_AddObject(m, "Component", (PyObject *)&Component_Type); /* Backward-compatible name */ Py_INCREF(&Component_Type); PyModule_AddObject(m, "ComponentType", (PyObject *)&Component_Type); } /* ========================= End module _Cm ========================= */