From b996856d12ac43ea6c1cb3697083f5d331de8e15 Mon Sep 17 00:00:00 2001 From: Jack Jansen Date: Thu, 30 Nov 1995 15:03:09 +0000 Subject: Component mgr support --- Mac/Lib/test/cmtest.py | 45 +++ Mac/Lib/toolbox/Components.py | 23 ++ Mac/Modules/cm/Cmgen.py | 158 +++++++++ Mac/Modules/cm/Cmmodule.c | 766 ++++++++++++++++++++++++++++++++++++++++++ Mac/Modules/cm/cmscan.py | 65 ++++ Mac/Modules/cm/cmsupport.py | 108 ++++++ 6 files changed, 1165 insertions(+) create mode 100644 Mac/Lib/test/cmtest.py create mode 100644 Mac/Lib/toolbox/Components.py create mode 100644 Mac/Modules/cm/Cmgen.py create mode 100644 Mac/Modules/cm/Cmmodule.c create mode 100644 Mac/Modules/cm/cmscan.py create mode 100644 Mac/Modules/cm/cmsupport.py diff --git a/Mac/Lib/test/cmtest.py b/Mac/Lib/test/cmtest.py new file mode 100644 index 0000000..7170424 --- /dev/null +++ b/Mac/Lib/test/cmtest.py @@ -0,0 +1,45 @@ +"""cmtest - List all components in the system""" + +import Cm +import Res +import sys + +def getstr255(r): + """Get string from str255 resource""" + if not r.data: return '' + len = ord(r.data[0]) + return r.data[1:1+len] + +def getinfo(c): + """Return (type, subtype, creator, fl1, fl2, name, description) for component""" + h1 = Res.Resource('') + h2 = Res.Resource('') + h3 = Res.Resource('') + type, subtype, creator, fl1, fl2 = c.GetComponentInfo(h1, h2, h3) + name = getstr255(h1) + description = getstr255(h2) + return type, subtype, creator, fl1, fl2, name, description + +def getallcomponents(): + """Return list with info for all components, sorted""" + any = ('\0\0\0\0', '\0\0\0\0', '\0\0\0\0', 0, 0) + c = None + rv = [] + while 1: + try: + c = Cm.FindNextComponent(c, any) + except Cm.Error: + break + rv.append(getinfo(c)) + rv.sort() + return rv + +def main(): + """Print info for all components""" + info = getallcomponents() + for type, subtype, creator, f1, f2, name, description in info: + print '%4.4s %4.4s %4.4s %s 0x%x 0x%x'%(type, subtype, creator, name, f1, f2) + print ' ', description + sys.exit(1) + +main() diff --git a/Mac/Lib/toolbox/Components.py b/Mac/Lib/toolbox/Components.py new file mode 100644 index 0000000..d211cec --- /dev/null +++ b/Mac/Lib/toolbox/Components.py @@ -0,0 +1,23 @@ +# Generated from 'Sap:CodeWarrior7:Metrowerks CodeWarrior:MacOS Support:Headers:Universal Headers:Components.h' + +kAppleManufacturer = 'appl' +kComponentResourceType = 'thng' +kAnyComponentType = 0 +kAnyComponentSubType = 0 +kAnyComponentManufacturer = 0 +kAnyComponentFlagsMask = 0 +cmpWantsRegisterMessage = 1L << 31 +kComponentOpenSelect = -1 +kComponentCloseSelect = -2 +kComponentCanDoSelect = -3 +kComponentVersionSelect = -4 +kComponentRegisterSelect = -5 +kComponentTargetSelect = -6 +kComponentUnregisterSelect = -7 +defaultComponentIdentical = 0 +defaultComponentAnyFlags = 1 +defaultComponentAnyManufacturer = 2 +defaultComponentAnySubType = 4 +registerComponentGlobal = 1 +registerComponentNoDuplicates = 2 +registerComponentAfterExisting = 4 diff --git a/Mac/Modules/cm/Cmgen.py b/Mac/Modules/cm/Cmgen.py new file mode 100644 index 0000000..f3b8991 --- /dev/null +++ b/Mac/Modules/cm/Cmgen.py @@ -0,0 +1,158 @@ +# Generated from 'Sap:CodeWarrior7:Metrowerks CodeWarrior:MacOS Support:Headers:Universal Headers:Components.h' + +f = Function(Component, 'RegisterComponentResource', + (ComponentResourceHandle, 'tr', InMode), + (short, 'global', InMode), +) +functions.append(f) + +f = Method(OSErr, 'UnregisterComponent', + (Component, 'aComponent', InMode), +) +c_methods.append(f) + +f = Function(Component, 'FindNextComponent', + (Component, 'aComponent', InMode), + (ComponentDescription, 'looking', InMode), +) +functions.append(f) + +f = Function(long, 'CountComponents', + (ComponentDescription, 'looking', InMode), +) +functions.append(f) + +f = Method(OSErr, 'GetComponentInfo', + (Component, 'aComponent', InMode), + (ComponentDescription, 'cd', OutMode), + (Handle, 'componentName', InMode), + (Handle, 'componentInfo', InMode), + (Handle, 'componentIcon', InMode), +) +c_methods.append(f) + +f = Function(long, 'GetComponentListModSeed', +) +functions.append(f) + +f = Method(ComponentInstance, 'OpenComponent', + (Component, 'aComponent', InMode), +) +c_methods.append(f) + +f = Method(OSErr, 'CloseComponent', + (ComponentInstance, 'aComponentInstance', InMode), +) +ci_methods.append(f) + +f = Method(OSErr, 'GetComponentInstanceError', + (ComponentInstance, 'aComponentInstance', InMode), +) +ci_methods.append(f) + +f = Method(long, 'ComponentFunctionImplemented', + (ComponentInstance, 'ci', InMode), + (short, 'ftnNumber', InMode), +) +ci_methods.append(f) + +f = Method(long, 'GetComponentVersion', + (ComponentInstance, 'ci', InMode), +) +ci_methods.append(f) + +f = Method(long, 'ComponentSetTarget', + (ComponentInstance, 'ci', InMode), + (ComponentInstance, 'target', InMode), +) +ci_methods.append(f) + +f = Method(void, 'SetComponentInstanceError', + (ComponentInstance, 'aComponentInstance', InMode), + (OSErr, 'theError', InMode), +) +ci_methods.append(f) + +f = Method(long, 'GetComponentRefcon', + (Component, 'aComponent', InMode), +) +c_methods.append(f) + +f = Method(void, 'SetComponentRefcon', + (Component, 'aComponent', InMode), + (long, 'theRefcon', InMode), +) +c_methods.append(f) + +f = Method(short, 'OpenComponentResFile', + (Component, 'aComponent', InMode), +) +c_methods.append(f) + +f = Function(OSErr, 'CloseComponentResFile', + (short, 'refnum', InMode), +) +functions.append(f) + +f = Method(Handle, 'GetComponentInstanceStorage', + (ComponentInstance, 'aComponentInstance', InMode), +) +ci_methods.append(f) + +f = Method(void, 'SetComponentInstanceStorage', + (ComponentInstance, 'aComponentInstance', InMode), + (Handle, 'theStorage', InMode), +) +ci_methods.append(f) + +f = Method(long, 'GetComponentInstanceA5', + (ComponentInstance, 'aComponentInstance', InMode), +) +ci_methods.append(f) + +f = Method(void, 'SetComponentInstanceA5', + (ComponentInstance, 'aComponentInstance', InMode), + (long, 'theA5', InMode), +) +ci_methods.append(f) + +f = Method(long, 'CountComponentInstances', + (Component, 'aComponent', InMode), +) +c_methods.append(f) + +f = Method(OSErr, 'SetDefaultComponent', + (Component, 'aComponent', InMode), + (short, 'flags', InMode), +) +c_methods.append(f) + +f = Function(ComponentInstance, 'OpenDefaultComponent', + (OSType, 'componentType', InMode), + (OSType, 'componentSubType', InMode), +) +functions.append(f) + +f = Method(Component, 'CaptureComponent', + (Component, 'capturedComponent', InMode), + (Component, 'capturingComponent', InMode), +) +c_methods.append(f) + +f = Method(OSErr, 'UncaptureComponent', + (Component, 'aComponent', InMode), +) +c_methods.append(f) + +f = Function(long, 'RegisterComponentResourceFile', + (short, 'resRefNum', InMode), + (short, 'global', InMode), +) +functions.append(f) + +f = Method(OSErr, 'GetComponentIconSuite', + (Component, 'aComponent', InMode), + (Handle, 'iconSuite', OutMode), +) +c_methods.append(f) + diff --git a/Mac/Modules/cm/Cmmodule.c b/Mac/Modules/cm/Cmmodule.c new file mode 100644 index 0000000..2f44307 --- /dev/null +++ b/Mac/Modules/cm/Cmmodule.c @@ -0,0 +1,766 @@ + +/* =========================== Module Cm ============================ */ + +#include "Python.h" + + + +#define SystemSevenOrLater 1 + +#include "macglue.h" +#include +#include +#include +#include + +extern PyObject *ResObj_New(Handle); +extern PyObject *ResObj_OptNew(Handle); +extern int ResObj_Convert(PyObject *, Handle *); + +extern PyObject *WinObj_New(WindowPtr); +extern int WinObj_Convert(PyObject *, WindowPtr *); +extern PyTypeObject Window_Type; +#define WinObj_Check(x) ((x)->ob_type == &Window_Type) + +extern PyObject *DlgObj_New(DialogPtr); +extern int DlgObj_Convert(PyObject *, DialogPtr *); +extern PyTypeObject Dialog_Type; +#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type) + +extern PyObject *MenuObj_New(MenuHandle); +extern int MenuObj_Convert(PyObject *, MenuHandle *); + +extern PyObject *CtlObj_New(ControlHandle); +extern int CtlObj_Convert(PyObject *, ControlHandle *); + +extern PyObject *GrafObj_New(GrafPtr); +extern int GrafObj_Convert(PyObject *, GrafPtr *); + +extern PyObject *BMObj_New(BitMapPtr); +extern int BMObj_Convert(PyObject *, BitMapPtr *); + +extern PyObject *WinObj_WhichWindow(WindowPtr); + +#include + +/* +** Parse/generate ComponentDescriptor records +*/ +PyObject *CmpDesc_New(itself) + 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); +} + +CmpDesc_Convert(v, p_itself) + 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(itself) + 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(v, p_itself) + 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(self) + ComponentInstanceObject *self; +{ + /* Cleanup of self->ob_itself goes here */ + PyMem_DEL(self); +} + +static PyObject *CmpInstObj_CloseComponent(_self, _args) + 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(_self, _args) + 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_ComponentFunctionImplemented(_self, _args) + 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(_self, _args) + 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(_self, _args) + 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 PyObject *CmpInstObj_SetComponentInstanceError(_self, _args) + 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(_self, _args) + 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(_self, _args) + 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; +} + +static PyObject *CmpInstObj_GetComponentInstanceA5(_self, _args) + 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; +} + +static PyObject *CmpInstObj_SetComponentInstanceA5(_self, _args) + 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; +} + +static PyMethodDef CmpInstObj_methods[] = { + {"CloseComponent", (PyCFunction)CmpInstObj_CloseComponent, 1, + "() -> None"}, + {"GetComponentInstanceError", (PyCFunction)CmpInstObj_GetComponentInstanceError, 1, + "() -> None"}, + {"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)"}, + {"SetComponentInstanceError", (PyCFunction)CmpInstObj_SetComponentInstanceError, 1, + "(OSErr theError) -> None"}, + {"GetComponentInstanceStorage", (PyCFunction)CmpInstObj_GetComponentInstanceStorage, 1, + "() -> (Handle _rv)"}, + {"SetComponentInstanceStorage", (PyCFunction)CmpInstObj_SetComponentInstanceStorage, 1, + "(Handle theStorage) -> None"}, + {"GetComponentInstanceA5", (PyCFunction)CmpInstObj_GetComponentInstanceA5, 1, + "() -> (long _rv)"}, + {"SetComponentInstanceA5", (PyCFunction)CmpInstObj_SetComponentInstanceA5, 1, + "(long theA5) -> None"}, + {NULL, NULL, 0} +}; + +PyMethodChain CmpInstObj_chain = { CmpInstObj_methods, NULL }; + +static PyObject *CmpInstObj_getattr(self, name) + ComponentInstanceObject *self; + char *name; +{ + return Py_FindMethodInChain(&CmpInstObj_chain, (PyObject *)self, name); +} + +#define CmpInstObj_setattr 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*/ +}; + +/* --------------- 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(itself) + 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(v, p_itself) + 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(self) + ComponentObject *self; +{ + /* Cleanup of self->ob_itself goes here */ + PyMem_DEL(self); +} + +static PyObject *CmpObj_UnregisterComponent(_self, _args) + 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(_self, _args) + 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(_self, _args) + 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(_self, _args) + 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(_self, _args) + 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(_self, _args) + 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_CountComponentInstances(_self, _args) + 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(_self, _args) + 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(_self, _args) + 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(_self, _args) + 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(_self, _args) + 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)"}, + {"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(self, name) + ComponentObject *self; + char *name; +{ + return Py_FindMethodInChain(&CmpObj_chain, (PyObject *)self, name); +} + +#define CmpObj_setattr 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*/ +}; + +/* ------------------- End object type Component -------------------- */ + + +static PyObject *Cm_RegisterComponentResource(_self, _args) + PyObject *_self; + PyObject *_args; +{ + PyObject *_res = NULL; + Component _rv; + ComponentResourceHandle tr; + short global; + if (!PyArg_ParseTuple(_args, "O&h", + ResObj_Convert, &tr, + &global)) + return NULL; + _rv = RegisterComponentResource(tr, + global); + _res = Py_BuildValue("O&", + CmpObj_New, _rv); + return _res; +} + +static PyObject *Cm_FindNextComponent(_self, _args) + 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(_self, _args) + 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(_self, _args) + 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(_self, _args) + 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(_self, _args) + 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(_self, _args) + 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 tr, 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 initCm() +{ + PyObject *m; + PyObject *d; + + + + + 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) + Py_FatalError("can't initialize Cm.Error"); +} + +/* ========================= End module Cm ========================== */ + diff --git a/Mac/Modules/cm/cmscan.py b/Mac/Modules/cm/cmscan.py new file mode 100644 index 0000000..d568a73 --- /dev/null +++ b/Mac/Modules/cm/cmscan.py @@ -0,0 +1,65 @@ +# Scan an Apple header file, generating a Python file of generator calls. + +import addpack +addpack.addpack(':tools:bgen:bgen') +from scantools import Scanner + +LONG = "Components" +SHORT = "Cm" + +def main(): + input = "Components.h" + output = SHORT + "gen.py" + defsoutput = LONG + ".py" + scanner = MyScanner(input, output, defsoutput) + scanner.scan() + scanner.close() + print "=== Done scanning and generating, now importing the generated code... ===" + exec "import " + SHORT + "support" + print "=== Done. It's up to you to compile it now! ===" + +class MyScanner(Scanner): + + def destination(self, type, name, arglist): + classname = "Function" + listname = "functions" + if arglist: + t, n, m = arglist[0] + # + # FindNextComponent is a special case, since it call also be called + # with None as the argument. Hence, we make it a function + # + if t == "Component" and m == "InMode" and name != "FindNextComponent": + classname = "Method" + listname = "c_methods" + elif t == "ComponentInstance" and m == "InMode": + classname = "Method" + listname = "ci_methods" + return classname, listname + + def makeblacklistnames(self): + return [ + # "GetComponentInfo" # XXXX I dont know how the Handle args are expected... + ] + + def makeblacklisttypes(self): + return [ + "ResourceSpec", + "ComponentResource", + "ComponentPlatformInfo", + "ComponentResourceExtension", + "ComponentPlatformInfoArray", + "ExtComponentResource", + "ComponentParameters", + + "ComponentRoutineUPP", + ] + + def makerepairinstructions(self): + return [ + ([('ComponentDescription', 'looking', 'OutMode')], + [('ComponentDescription', '*', 'InMode')]), + ] + +if __name__ == "__main__": + main() diff --git a/Mac/Modules/cm/cmsupport.py b/Mac/Modules/cm/cmsupport.py new file mode 100644 index 0000000..0a1915f --- /dev/null +++ b/Mac/Modules/cm/cmsupport.py @@ -0,0 +1,108 @@ +# This script generates a Python interface for an Apple Macintosh Manager. +# It uses the "bgen" package to generate C code. +# The function specifications are generated by scanning the mamager's header file, +# using the "scantools" package (customized for this particular manager). + +import string + +# Declarations that change for each manager +MACHEADERFILE = 'Components.h' # The Apple header file +MODNAME = 'Cm' # The name of the module + +# The following is *usually* unchanged but may still require tuning +MODPREFIX = MODNAME # The prefix for module-wide routines +C_OBJECTPREFIX = 'CmpObj' # The prefix for object methods +CI_OBJECTPREFIX = 'CmpInstObj' +INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner +OUTPUTFILE = MODNAME + "module.c" # The file generated by this program + +from macsupport import * + +# Create the type objects + +includestuff = includestuff + """ +#include <%s>""" % MACHEADERFILE + """ + +/* +** Parse/generate ComponentDescriptor records +*/ +PyObject *CmpDesc_New(itself) + 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); +} + +CmpDesc_Convert(v, p_itself) + 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); +} + +""" + +ComponentDescription = OpaqueType('ComponentDescription', 'CmpDesc') +Component = OpaqueByValueType('Component', C_OBJECTPREFIX) +ComponentInstance = OpaqueByValueType('ComponentInstance', CI_OBJECTPREFIX) +ComponentResult = Type("ComponentResult", "l") + +ComponentResourceHandle = OpaqueByValueType("ComponentResourceHandle", "ResObj") + +class MyCIObjectDefinition(GlobalObjectDefinition): + def outputCheckNewArg(self): + Output("""if (itself == NULL) { + PyErr_SetString(Cm_Error,"NULL ComponentInstance"); + return NULL; + }""") + +class MyCObjectDefinition(GlobalObjectDefinition): + def outputCheckNewArg(self): + Output("""if (itself == NULL) { + /* XXXX Or should we return None? */ + PyErr_SetString(Cm_Error,"No such component"); + return NULL; + }""") + + def outputCheckConvertArg(self): + Output("""if ( v == Py_None ) { + *p_itself = 0; + return 1; + }""") + +# Create the generator groups and link them +module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff) +ci_object = MyCIObjectDefinition('ComponentInstance', CI_OBJECTPREFIX, + 'ComponentInstance') +c_object = MyCObjectDefinition('Component', C_OBJECTPREFIX, 'Component') +module.addobject(ci_object) +module.addobject(c_object) + +# Create the generator classes used to populate the lists +Function = OSErrFunctionGenerator +Method = OSErrMethodGenerator + +# Create and populate the lists +functions = [] +c_methods = [] +ci_methods = [] +execfile(INPUTFILE) + +# add the populated lists to the generator groups +# (in a different wordl the scan program would generate this) +for f in functions: module.add(f) +for f in c_methods: c_object.add(f) +for f in ci_methods: ci_object.add(f) + +# generate output (open the output file as late as possible) +SetOutputFileName(OUTPUTFILE) +module.generate() + -- cgit v0.12