mirror of https://github.com/python/cpython
923 lines
25 KiB
C
923 lines
25 KiB
C
|
|
/* =========================== Module _Cm =========================== */
|
|
|
|
#include "Python.h"
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
#include "pywintoolbox.h"
|
|
#else
|
|
#include "macglue.h"
|
|
#include "pymactoolbox.h"
|
|
#endif
|
|
|
|
/* Macro to test whether a weak-loaded CFM function exists */
|
|
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
|
|
PyErr_SetString(PyExc_NotImplementedError, \
|
|
"Not available in this shared library/OS version"); \
|
|
return NULL; \
|
|
}} while(0)
|
|
|
|
|
|
#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;
|
|
}
|
|
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 */
|
|
PyObject_Del(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;
|
|
}
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
|
|
static PyObject *CmpInstObj_GetComponentInstanceA5(ComponentInstanceObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
long _rv;
|
|
#ifndef GetComponentInstanceA5
|
|
PyMac_PRECHECK(GetComponentInstanceA5);
|
|
#endif
|
|
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;
|
|
#ifndef SetComponentInstanceA5
|
|
PyMac_PRECHECK(SetComponentInstanceA5);
|
|
#endif
|
|
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;
|
|
#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;
|
|
}
|
|
|
|
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(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) 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;
|
|
}
|
|
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 */
|
|
PyObject_Del(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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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)"},
|
|
{"ResolveComponentAlias", (PyCFunction)CmpObj_ResolveComponentAlias, 1,
|
|
"() -> (Component _rv)"},
|
|
{"GetComponentPublicIndString", (PyCFunction)CmpObj_GetComponentPublicIndString, 1,
|
|
"(Str255 theString, short strListID, short index) -> None"},
|
|
{"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"},
|
|
{"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(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) 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;
|
|
#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,
|
|
"(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 ========================= */
|
|
|