1 

     2 /* =========================== Module _Cm =========================== */

     3 

     4 #include "Python.h"

     5 

     6 

     7 

     8 #include "pymactoolbox.h"

     9 

    10 /* Macro to test whether a weak-loaded CFM function exists */

    11 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\

    12         PyErr_SetString(PyExc_NotImplementedError, \

    13         "Not available in this shared library/OS version"); \

    14         return NULL; \

    15     }} while(0)

    16 

    17 

    18 #include <Carbon/Carbon.h>

    19 

    20 #ifdef USE_TOOLBOX_OBJECT_GLUE

    21 extern PyObject *_CmpObj_New(Component);

    22 extern int _CmpObj_Convert(PyObject *, Component *);

    23 extern PyObject *_CmpInstObj_New(ComponentInstance);

    24 extern int _CmpInstObj_Convert(PyObject *, ComponentInstance *);

    25 

    26 #define CmpObj_New _CmpObj_New

    27 #define CmpObj_Convert _CmpObj_Convert

    28 #define CmpInstObj_New _CmpInstObj_New

    29 #define CmpInstObj_Convert _CmpInstObj_Convert

    30 #endif

    31 

    32 /*

    33 ** Parse/generate ComponentDescriptor records

    34 */

    35 static PyObject *

    36 CmpDesc_New(ComponentDescription *itself)

    37 {

    38 

    39         return Py_BuildValue("O&O&O&ll",

    40                 PyMac_BuildOSType, itself->componentType,

    41                 PyMac_BuildOSType, itself->componentSubType,

    42                 PyMac_BuildOSType, itself->componentManufacturer,

    43                 itself->componentFlags, itself->componentFlagsMask);

    44 }

    45 

    46 static int

    47 CmpDesc_Convert(PyObject *v, ComponentDescription *p_itself)

    48 {

    49         return PyArg_ParseTuple(v, "O&O&O&ll",

    50                 PyMac_GetOSType, &p_itself->componentType,

    51                 PyMac_GetOSType, &p_itself->componentSubType,

    52                 PyMac_GetOSType, &p_itself->componentManufacturer,

    53                 &p_itself->componentFlags, &p_itself->componentFlagsMask);

    54 }

    55 

    56 

    57 static PyObject *Cm_Error;

    58 

    59 /* ----------------- Object type ComponentInstance ------------------ */

    60 

    61 PyTypeObject ComponentInstance_Type;

    62 

    63 #define CmpInstObj_Check(x) ((x)->ob_type == &ComponentInstance_Type || PyObject_TypeCheck((x), &ComponentInstance_Type))

    64 

    65 typedef struct ComponentInstanceObject {

    66 	PyObject_HEAD

    67 	ComponentInstance ob_itself;

    68 } ComponentInstanceObject;

    69 

    70 PyObject *CmpInstObj_New(ComponentInstance itself)

    71 {

    72 	ComponentInstanceObject *it;

    73 	if (itself == NULL) {

    74 	                                PyErr_SetString(Cm_Error,"NULL ComponentInstance");

    75 	                                return NULL;

    76 	                        }

    77 	it = PyObject_NEW(ComponentInstanceObject, &ComponentInstance_Type);

    78 	if (it == NULL) return NULL;

    79 	it->ob_itself = itself;

    80 	return (PyObject *)it;

    81 }

    82 

    83 int CmpInstObj_Convert(PyObject *v, ComponentInstance *p_itself)

    84 {

    85 	if (!CmpInstObj_Check(v))

    86 	{

    87 		PyErr_SetString(PyExc_TypeError, "ComponentInstance required");

    88 		return 0;

    89 	}

    90 	*p_itself = ((ComponentInstanceObject *)v)->ob_itself;

    91 	return 1;

    92 }

    93 

    94 static void CmpInstObj_dealloc(ComponentInstanceObject *self)

    95 {

    96 	/* Cleanup of self->ob_itself goes here */

    97 	self->ob_type->tp_free((PyObject *)self);

    98 }

    99 

   100 static PyObject *CmpInstObj_CloseComponent(ComponentInstanceObject *_self, PyObject *_args)

   101 {

   102 	PyObject *_res = NULL;

   103 	OSErr _err;

   104 #ifndef CloseComponent

   105 	PyMac_PRECHECK(CloseComponent);

   106 #endif

   107 	if (!PyArg_ParseTuple(_args, ""))

   108 		return NULL;

   109 	_err = CloseComponent(_self->ob_itself);

   110 	if (_err != noErr) return PyMac_Error(_err);

   111 	Py_INCREF(Py_None);

   112 	_res = Py_None;

   113 	return _res;

   114 }

   115 

   116 static PyObject *CmpInstObj_GetComponentInstanceError(ComponentInstanceObject *_self, PyObject *_args)

   117 {

   118 	PyObject *_res = NULL;

   119 	OSErr _err;

   120 #ifndef GetComponentInstanceError

   121 	PyMac_PRECHECK(GetComponentInstanceError);

   122 #endif

   123 	if (!PyArg_ParseTuple(_args, ""))

   124 		return NULL;

   125 	_err = GetComponentInstanceError(_self->ob_itself);

   126 	if (_err != noErr) return PyMac_Error(_err);

   127 	Py_INCREF(Py_None);

   128 	_res = Py_None;

   129 	return _res;

   130 }

   131 

   132 static PyObject *CmpInstObj_SetComponentInstanceError(ComponentInstanceObject *_self, PyObject *_args)

   133 {

   134 	PyObject *_res = NULL;

   135 	OSErr theError;

   136 #ifndef SetComponentInstanceError

   137 	PyMac_PRECHECK(SetComponentInstanceError);

   138 #endif

   139 	if (!PyArg_ParseTuple(_args, "h",

   140 	                      &theError))

   141 		return NULL;

   142 	SetComponentInstanceError(_self->ob_itself,

   143 	                          theError);

   144 	Py_INCREF(Py_None);

   145 	_res = Py_None;

   146 	return _res;

   147 }

   148 

   149 static PyObject *CmpInstObj_GetComponentInstanceStorage(ComponentInstanceObject *_self, PyObject *_args)

   150 {

   151 	PyObject *_res = NULL;

   152 	Handle _rv;

   153 #ifndef GetComponentInstanceStorage

   154 	PyMac_PRECHECK(GetComponentInstanceStorage);

   155 #endif

   156 	if (!PyArg_ParseTuple(_args, ""))

   157 		return NULL;

   158 	_rv = GetComponentInstanceStorage(_self->ob_itself);

   159 	_res = Py_BuildValue("O&",

   160 	                     ResObj_New, _rv);

   161 	return _res;

   162 }

   163 

   164 static PyObject *CmpInstObj_SetComponentInstanceStorage(ComponentInstanceObject *_self, PyObject *_args)

   165 {

   166 	PyObject *_res = NULL;

   167 	Handle theStorage;

   168 #ifndef SetComponentInstanceStorage

   169 	PyMac_PRECHECK(SetComponentInstanceStorage);

   170 #endif

   171 	if (!PyArg_ParseTuple(_args, "O&",

   172 	                      ResObj_Convert, &theStorage))

   173 		return NULL;

   174 	SetComponentInstanceStorage(_self->ob_itself,

   175 	                            theStorage);

   176 	Py_INCREF(Py_None);

   177 	_res = Py_None;

   178 	return _res;

   179 }

   180 

   181 #ifndef __LP64__

   182 static PyObject *CmpInstObj_ComponentFunctionImplemented(ComponentInstanceObject *_self, PyObject *_args)

   183 {

   184 	PyObject *_res = NULL;

   185 	long _rv;

   186 	short ftnNumber;

   187 #ifndef ComponentFunctionImplemented

   188 	PyMac_PRECHECK(ComponentFunctionImplemented);

   189 #endif

   190 	if (!PyArg_ParseTuple(_args, "h",

   191 	                      &ftnNumber))

   192 		return NULL;

   193 	_rv = ComponentFunctionImplemented(_self->ob_itself,

   194 	                                   ftnNumber);

   195 	_res = Py_BuildValue("l",

   196 	                     _rv);

   197 	return _res;

   198 }

   199 

   200 static PyObject *CmpInstObj_GetComponentVersion(ComponentInstanceObject *_self, PyObject *_args)

   201 {

   202 	PyObject *_res = NULL;

   203 	long _rv;

   204 #ifndef GetComponentVersion

   205 	PyMac_PRECHECK(GetComponentVersion);

   206 #endif

   207 	if (!PyArg_ParseTuple(_args, ""))

   208 		return NULL;

   209 	_rv = GetComponentVersion(_self->ob_itself);

   210 	_res = Py_BuildValue("l",

   211 	                     _rv);

   212 	return _res;

   213 }

   214 

   215 static PyObject *CmpInstObj_ComponentSetTarget(ComponentInstanceObject *_self, PyObject *_args)

   216 {

   217 	PyObject *_res = NULL;

   218 	long _rv;

   219 	ComponentInstance target;

   220 #ifndef ComponentSetTarget

   221 	PyMac_PRECHECK(ComponentSetTarget);

   222 #endif

   223 	if (!PyArg_ParseTuple(_args, "O&",

   224 	                      CmpInstObj_Convert, &target))

   225 		return NULL;

   226 	_rv = ComponentSetTarget(_self->ob_itself,

   227 	                         target);

   228 	_res = Py_BuildValue("l",

   229 	                     _rv);

   230 	return _res;

   231 }

   232 #endif /* !__LP64__*/

   233 

   234 static PyMethodDef CmpInstObj_methods[] = {

   235 	{"CloseComponent", (PyCFunction)CmpInstObj_CloseComponent, 1,

   236 	 PyDoc_STR("() -> None")},

   237 	{"GetComponentInstanceError", (PyCFunction)CmpInstObj_GetComponentInstanceError, 1,

   238 	 PyDoc_STR("() -> None")},

   239 	{"SetComponentInstanceError", (PyCFunction)CmpInstObj_SetComponentInstanceError, 1,

   240 	 PyDoc_STR("(OSErr theError) -> None")},

   241 	{"GetComponentInstanceStorage", (PyCFunction)CmpInstObj_GetComponentInstanceStorage, 1,

   242 	 PyDoc_STR("() -> (Handle _rv)")},

   243 	{"SetComponentInstanceStorage", (PyCFunction)CmpInstObj_SetComponentInstanceStorage, 1,

   244 	 PyDoc_STR("(Handle theStorage) -> None")},

   245 #ifndef __LP64__

   246 	{"ComponentFunctionImplemented", (PyCFunction)CmpInstObj_ComponentFunctionImplemented, 1,

   247 	 PyDoc_STR("(short ftnNumber) -> (long _rv)")},

   248 	{"GetComponentVersion", (PyCFunction)CmpInstObj_GetComponentVersion, 1,

   249 	 PyDoc_STR("() -> (long _rv)")},

   250 	{"ComponentSetTarget", (PyCFunction)CmpInstObj_ComponentSetTarget, 1,

   251 	 PyDoc_STR("(ComponentInstance target) -> (long _rv)")},

   252 #endif /* !__LP64__ */

   253 	{NULL, NULL, 0}

   254 };

   255 

   256 #define CmpInstObj_getsetlist NULL

   257 

   258 

   259 #define CmpInstObj_compare NULL

   260 

   261 #define CmpInstObj_repr NULL

   262 

   263 #define CmpInstObj_hash NULL

   264 #define CmpInstObj_tp_init 0

   265 

   266 #define CmpInstObj_tp_alloc PyType_GenericAlloc

   267 

   268 static PyObject *CmpInstObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

   269 {

   270 	PyObject *_self;

   271 	ComponentInstance itself;

   272 	char *kw[] = {"itself", 0};

   273 

   274 	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CmpInstObj_Convert, &itself)) return NULL;

   275 	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;

   276 	((ComponentInstanceObject *)_self)->ob_itself = itself;

   277 	return _self;

   278 }

   279 

   280 #define CmpInstObj_tp_free PyObject_Del

   281 

   282 

   283 PyTypeObject ComponentInstance_Type = {

   284 	PyObject_HEAD_INIT(NULL)

   285 	0, /*ob_size*/

   286 	"_Cm.ComponentInstance", /*tp_name*/

   287 	sizeof(ComponentInstanceObject), /*tp_basicsize*/

   288 	0, /*tp_itemsize*/

   289 	/* methods */

   290 	(destructor) CmpInstObj_dealloc, /*tp_dealloc*/

   291 	0, /*tp_print*/

   292 	(getattrfunc)0, /*tp_getattr*/

   293 	(setattrfunc)0, /*tp_setattr*/

   294 	(cmpfunc) CmpInstObj_compare, /*tp_compare*/

   295 	(reprfunc) CmpInstObj_repr, /*tp_repr*/

   296 	(PyNumberMethods *)0, /* tp_as_number */

   297 	(PySequenceMethods *)0, /* tp_as_sequence */

   298 	(PyMappingMethods *)0, /* tp_as_mapping */

   299 	(hashfunc) CmpInstObj_hash, /*tp_hash*/

   300 	0, /*tp_call*/

   301 	0, /*tp_str*/

   302 	PyObject_GenericGetAttr, /*tp_getattro*/

   303 	PyObject_GenericSetAttr, /*tp_setattro */

   304 	0, /*tp_as_buffer*/

   305 	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

   306 	0, /*tp_doc*/

   307 	0, /*tp_traverse*/

   308 	0, /*tp_clear*/

   309 	0, /*tp_richcompare*/

   310 	0, /*tp_weaklistoffset*/

   311 	0, /*tp_iter*/

   312 	0, /*tp_iternext*/

   313 	CmpInstObj_methods, /* tp_methods */

   314 	0, /*tp_members*/

   315 	CmpInstObj_getsetlist, /*tp_getset*/

   316 	0, /*tp_base*/

   317 	0, /*tp_dict*/

   318 	0, /*tp_descr_get*/

   319 	0, /*tp_descr_set*/

   320 	0, /*tp_dictoffset*/

   321 	CmpInstObj_tp_init, /* tp_init */

   322 	CmpInstObj_tp_alloc, /* tp_alloc */

   323 	CmpInstObj_tp_new, /* tp_new */

   324 	CmpInstObj_tp_free, /* tp_free */

   325 };

   326 

   327 /* --------------- End object type ComponentInstance ---------------- */

   328 

   329 

   330 /* --------------------- Object type Component ---------------------- */

   331 

   332 PyTypeObject Component_Type;

   333 

   334 #define CmpObj_Check(x) ((x)->ob_type == &Component_Type || PyObject_TypeCheck((x), &Component_Type))

   335 

   336 typedef struct ComponentObject {

   337 	PyObject_HEAD

   338 	Component ob_itself;

   339 } ComponentObject;

   340 

   341 PyObject *CmpObj_New(Component itself)

   342 {

   343 	ComponentObject *it;

   344 	if (itself == NULL) {

   345 	                                /* XXXX Or should we return None? */

   346 	                                PyErr_SetString(Cm_Error,"No such component");

   347 	                                return NULL;

   348 	                        }

   349 	it = PyObject_NEW(ComponentObject, &Component_Type);

   350 	if (it == NULL) return NULL;

   351 	it->ob_itself = itself;

   352 	return (PyObject *)it;

   353 }

   354 

   355 int CmpObj_Convert(PyObject *v, Component *p_itself)

   356 {

   357 	if ( v == Py_None ) {

   358 	                                *p_itself = 0;

   359 	                                return 1;

   360 	        }

   361 	if (!CmpObj_Check(v))

   362 	{

   363 		PyErr_SetString(PyExc_TypeError, "Component required");

   364 		return 0;

   365 	}

   366 	*p_itself = ((ComponentObject *)v)->ob_itself;

   367 	return 1;

   368 }

   369 

   370 static void CmpObj_dealloc(ComponentObject *self)

   371 {

   372 	/* Cleanup of self->ob_itself goes here */

   373 	self->ob_type->tp_free((PyObject *)self);

   374 }

   375 

   376 static PyObject *CmpObj_UnregisterComponent(ComponentObject *_self, PyObject *_args)

   377 {

   378 	PyObject *_res = NULL;

   379 	OSErr _err;

   380 #ifndef UnregisterComponent

   381 	PyMac_PRECHECK(UnregisterComponent);

   382 #endif

   383 	if (!PyArg_ParseTuple(_args, ""))

   384 		return NULL;

   385 	_err = UnregisterComponent(_self->ob_itself);

   386 	if (_err != noErr) return PyMac_Error(_err);

   387 	Py_INCREF(Py_None);

   388 	_res = Py_None;

   389 	return _res;

   390 }

   391 

   392 static PyObject *CmpObj_GetComponentInfo(ComponentObject *_self, PyObject *_args)

   393 {

   394 	PyObject *_res = NULL;

   395 	OSErr _err;

   396 	ComponentDescription cd;

   397 	Handle componentName;

   398 	Handle componentInfo;

   399 	Handle componentIcon;

   400 #ifndef GetComponentInfo

   401 	PyMac_PRECHECK(GetComponentInfo);

   402 #endif

   403 	if (!PyArg_ParseTuple(_args, "O&O&O&",

   404 	                      ResObj_Convert, &componentName,

   405 	                      ResObj_Convert, &componentInfo,

   406 	                      ResObj_Convert, &componentIcon))

   407 		return NULL;

   408 	_err = GetComponentInfo(_self->ob_itself,

   409 	                        &cd,

   410 	                        componentName,

   411 	                        componentInfo,

   412 	                        componentIcon);

   413 	if (_err != noErr) return PyMac_Error(_err);

   414 	_res = Py_BuildValue("O&",

   415 	                     CmpDesc_New, &cd);

   416 	return _res;

   417 }

   418 

   419 static PyObject *CmpObj_OpenComponent(ComponentObject *_self, PyObject *_args)

   420 {

   421 	PyObject *_res = NULL;

   422 	ComponentInstance _rv;

   423 #ifndef OpenComponent

   424 	PyMac_PRECHECK(OpenComponent);

   425 #endif

   426 	if (!PyArg_ParseTuple(_args, ""))

   427 		return NULL;

   428 	_rv = OpenComponent(_self->ob_itself);

   429 	_res = Py_BuildValue("O&",

   430 	                     CmpInstObj_New, _rv);

   431 	return _res;

   432 }

   433 

   434 static PyObject *CmpObj_ResolveComponentAlias(ComponentObject *_self, PyObject *_args)

   435 {

   436 	PyObject *_res = NULL;

   437 	Component _rv;

   438 #ifndef ResolveComponentAlias

   439 	PyMac_PRECHECK(ResolveComponentAlias);

   440 #endif

   441 	if (!PyArg_ParseTuple(_args, ""))

   442 		return NULL;

   443 	_rv = ResolveComponentAlias(_self->ob_itself);

   444 	_res = Py_BuildValue("O&",

   445 	                     CmpObj_New, _rv);

   446 	return _res;

   447 }

   448 

   449 static PyObject *CmpObj_GetComponentPublicIndString(ComponentObject *_self, PyObject *_args)

   450 {

   451 	PyObject *_res = NULL;

   452 	OSErr _err;

   453 	Str255 theString;

   454 	short strListID;

   455 	short index;

   456 #ifndef GetComponentPublicIndString

   457 	PyMac_PRECHECK(GetComponentPublicIndString);

   458 #endif

   459 	if (!PyArg_ParseTuple(_args, "O&hh",

   460 	                      PyMac_GetStr255, theString,

   461 	                      &strListID,

   462 	                      &index))

   463 		return NULL;

   464 	_err = GetComponentPublicIndString(_self->ob_itself,

   465 	                                   theString,

   466 	                                   strListID,

   467 	                                   index);

   468 	if (_err != noErr) return PyMac_Error(_err);

   469 	Py_INCREF(Py_None);

   470 	_res = Py_None;

   471 	return _res;

   472 }

   473 

   474 static PyObject *CmpObj_GetComponentRefcon(ComponentObject *_self, PyObject *_args)

   475 {

   476 	PyObject *_res = NULL;

   477 	long _rv;

   478 #ifndef GetComponentRefcon

   479 	PyMac_PRECHECK(GetComponentRefcon);

   480 #endif

   481 	if (!PyArg_ParseTuple(_args, ""))

   482 		return NULL;

   483 	_rv = GetComponentRefcon(_self->ob_itself);

   484 	_res = Py_BuildValue("l",

   485 	                     _rv);

   486 	return _res;

   487 }

   488 

   489 static PyObject *CmpObj_SetComponentRefcon(ComponentObject *_self, PyObject *_args)

   490 {

   491 	PyObject *_res = NULL;

   492 	long theRefcon;

   493 #ifndef SetComponentRefcon

   494 	PyMac_PRECHECK(SetComponentRefcon);

   495 #endif

   496 	if (!PyArg_ParseTuple(_args, "l",

   497 	                      &theRefcon))

   498 		return NULL;

   499 	SetComponentRefcon(_self->ob_itself,

   500 	                   theRefcon);

   501 	Py_INCREF(Py_None);

   502 	_res = Py_None;

   503 	return _res;

   504 }

   505 

   506 static PyObject *CmpObj_OpenComponentResFile(ComponentObject *_self, PyObject *_args)

   507 {

   508 	PyObject *_res = NULL;

   509 	short _rv;

   510 #ifndef OpenComponentResFile

   511 	PyMac_PRECHECK(OpenComponentResFile);

   512 #endif

   513 	if (!PyArg_ParseTuple(_args, ""))

   514 		return NULL;

   515 	_rv = OpenComponentResFile(_self->ob_itself);

   516 	_res = Py_BuildValue("h",

   517 	                     _rv);

   518 	return _res;

   519 }

   520 

   521 static PyObject *CmpObj_GetComponentResource(ComponentObject *_self, PyObject *_args)

   522 {

   523 	PyObject *_res = NULL;

   524 	OSErr _err;

   525 	OSType resType;

   526 	short resID;

   527 	Handle theResource;

   528 #ifndef GetComponentResource

   529 	PyMac_PRECHECK(GetComponentResource);

   530 #endif

   531 	if (!PyArg_ParseTuple(_args, "O&h",

   532 	                      PyMac_GetOSType, &resType,

   533 	                      &resID))

   534 		return NULL;

   535 	_err = GetComponentResource(_self->ob_itself,

   536 	                            resType,

   537 	                            resID,

   538 	                            &theResource);

   539 	if (_err != noErr) return PyMac_Error(_err);

   540 	_res = Py_BuildValue("O&",

   541 	                     ResObj_New, theResource);

   542 	return _res;

   543 }

   544 

   545 static PyObject *CmpObj_GetComponentIndString(ComponentObject *_self, PyObject *_args)

   546 {

   547 	PyObject *_res = NULL;

   548 	OSErr _err;

   549 	Str255 theString;

   550 	short strListID;

   551 	short index;

   552 #ifndef GetComponentIndString

   553 	PyMac_PRECHECK(GetComponentIndString);

   554 #endif

   555 	if (!PyArg_ParseTuple(_args, "O&hh",

   556 	                      PyMac_GetStr255, theString,

   557 	                      &strListID,

   558 	                      &index))

   559 		return NULL;

   560 	_err = GetComponentIndString(_self->ob_itself,

   561 	                             theString,

   562 	                             strListID,

   563 	                             index);

   564 	if (_err != noErr) return PyMac_Error(_err);

   565 	Py_INCREF(Py_None);

   566 	_res = Py_None;

   567 	return _res;

   568 }

   569 

   570 static PyObject *CmpObj_CountComponentInstances(ComponentObject *_self, PyObject *_args)

   571 {

   572 	PyObject *_res = NULL;

   573 	long _rv;

   574 #ifndef CountComponentInstances

   575 	PyMac_PRECHECK(CountComponentInstances);

   576 #endif

   577 	if (!PyArg_ParseTuple(_args, ""))

   578 		return NULL;

   579 	_rv = CountComponentInstances(_self->ob_itself);

   580 	_res = Py_BuildValue("l",

   581 	                     _rv);

   582 	return _res;

   583 }

   584 

   585 static PyObject *CmpObj_SetDefaultComponent(ComponentObject *_self, PyObject *_args)

   586 {

   587 	PyObject *_res = NULL;

   588 	OSErr _err;

   589 	short flags;

   590 #ifndef SetDefaultComponent

   591 	PyMac_PRECHECK(SetDefaultComponent);

   592 #endif

   593 	if (!PyArg_ParseTuple(_args, "h",

   594 	                      &flags))

   595 		return NULL;

   596 	_err = SetDefaultComponent(_self->ob_itself,

   597 	                           flags);

   598 	if (_err != noErr) return PyMac_Error(_err);

   599 	Py_INCREF(Py_None);

   600 	_res = Py_None;

   601 	return _res;

   602 }

   603 

   604 static PyObject *CmpObj_CaptureComponent(ComponentObject *_self, PyObject *_args)

   605 {

   606 	PyObject *_res = NULL;

   607 	Component _rv;

   608 	Component capturingComponent;

   609 #ifndef CaptureComponent

   610 	PyMac_PRECHECK(CaptureComponent);

   611 #endif

   612 	if (!PyArg_ParseTuple(_args, "O&",

   613 	                      CmpObj_Convert, &capturingComponent))

   614 		return NULL;

   615 	_rv = CaptureComponent(_self->ob_itself,

   616 	                       capturingComponent);

   617 	_res = Py_BuildValue("O&",

   618 	                     CmpObj_New, _rv);

   619 	return _res;

   620 }

   621 

   622 static PyObject *CmpObj_UncaptureComponent(ComponentObject *_self, PyObject *_args)

   623 {

   624 	PyObject *_res = NULL;

   625 	OSErr _err;

   626 #ifndef UncaptureComponent

   627 	PyMac_PRECHECK(UncaptureComponent);

   628 #endif

   629 	if (!PyArg_ParseTuple(_args, ""))

   630 		return NULL;

   631 	_err = UncaptureComponent(_self->ob_itself);

   632 	if (_err != noErr) return PyMac_Error(_err);

   633 	Py_INCREF(Py_None);

   634 	_res = Py_None;

   635 	return _res;

   636 }

   637 

   638 #ifndef __LP64__

   639 static PyObject *CmpObj_GetComponentIconSuite(ComponentObject *_self, PyObject *_args)

   640 {

   641 	PyObject *_res = NULL;

   642 	OSErr _err;

   643 	Handle iconSuite;

   644 #ifndef GetComponentIconSuite

   645 	PyMac_PRECHECK(GetComponentIconSuite);

   646 #endif

   647 	if (!PyArg_ParseTuple(_args, ""))

   648 		return NULL;

   649 	_err = GetComponentIconSuite(_self->ob_itself,

   650 	                             &iconSuite);

   651 	if (_err != noErr) return PyMac_Error(_err);

   652 	_res = Py_BuildValue("O&",

   653 	                     ResObj_New, iconSuite);

   654 	return _res;

   655 }

   656 #endif /* !__LP64__ */

   657 

   658 static PyMethodDef CmpObj_methods[] = {

   659 	{"UnregisterComponent", (PyCFunction)CmpObj_UnregisterComponent, 1,

   660 	 PyDoc_STR("() -> None")},

   661 	{"GetComponentInfo", (PyCFunction)CmpObj_GetComponentInfo, 1,

   662 	 PyDoc_STR("(Handle componentName, Handle componentInfo, Handle componentIcon) -> (ComponentDescription cd)")},

   663 	{"OpenComponent", (PyCFunction)CmpObj_OpenComponent, 1,

   664 	 PyDoc_STR("() -> (ComponentInstance _rv)")},

   665 	{"ResolveComponentAlias", (PyCFunction)CmpObj_ResolveComponentAlias, 1,

   666 	 PyDoc_STR("() -> (Component _rv)")},

   667 	{"GetComponentPublicIndString", (PyCFunction)CmpObj_GetComponentPublicIndString, 1,

   668 	 PyDoc_STR("(Str255 theString, short strListID, short index) -> None")},

   669 	{"GetComponentRefcon", (PyCFunction)CmpObj_GetComponentRefcon, 1,

   670 	 PyDoc_STR("() -> (long _rv)")},

   671 	{"SetComponentRefcon", (PyCFunction)CmpObj_SetComponentRefcon, 1,

   672 	 PyDoc_STR("(long theRefcon) -> None")},

   673 	{"OpenComponentResFile", (PyCFunction)CmpObj_OpenComponentResFile, 1,

   674 	 PyDoc_STR("() -> (short _rv)")},

   675 	{"GetComponentResource", (PyCFunction)CmpObj_GetComponentResource, 1,

   676 	 PyDoc_STR("(OSType resType, short resID) -> (Handle theResource)")},

   677 	{"GetComponentIndString", (PyCFunction)CmpObj_GetComponentIndString, 1,

   678 	 PyDoc_STR("(Str255 theString, short strListID, short index) -> None")},

   679 	{"CountComponentInstances", (PyCFunction)CmpObj_CountComponentInstances, 1,

   680 	 PyDoc_STR("() -> (long _rv)")},

   681 	{"SetDefaultComponent", (PyCFunction)CmpObj_SetDefaultComponent, 1,

   682 	 PyDoc_STR("(short flags) -> None")},

   683 	{"CaptureComponent", (PyCFunction)CmpObj_CaptureComponent, 1,

   684 	 PyDoc_STR("(Component capturingComponent) -> (Component _rv)")},

   685 	{"UncaptureComponent", (PyCFunction)CmpObj_UncaptureComponent, 1,

   686 	 PyDoc_STR("() -> None")},

   687 #ifndef __LP64__

   688 	{"GetComponentIconSuite", (PyCFunction)CmpObj_GetComponentIconSuite, 1,

   689 	 PyDoc_STR("() -> (Handle iconSuite)")},

   690 #endif /* !__LP64__ */

   691 	{NULL, NULL, 0}

   692 };

   693 

   694 #define CmpObj_getsetlist NULL

   695 

   696 

   697 #define CmpObj_compare NULL

   698 

   699 #define CmpObj_repr NULL

   700 

   701 #define CmpObj_hash NULL

   702 #define CmpObj_tp_init 0

   703 

   704 #define CmpObj_tp_alloc PyType_GenericAlloc

   705 

   706 static PyObject *CmpObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

   707 {

   708 	PyObject *_self;

   709 	Component itself;

   710 	char *kw[] = {"itself", 0};

   711 

   712 	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CmpObj_Convert, &itself)) return NULL;

   713 	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;

   714 	((ComponentObject *)_self)->ob_itself = itself;

   715 	return _self;

   716 }

   717 

   718 #define CmpObj_tp_free PyObject_Del

   719 

   720 

   721 PyTypeObject Component_Type = {

   722 	PyObject_HEAD_INIT(NULL)

   723 	0, /*ob_size*/

   724 	"_Cm.Component", /*tp_name*/

   725 	sizeof(ComponentObject), /*tp_basicsize*/

   726 	0, /*tp_itemsize*/

   727 	/* methods */

   728 	(destructor) CmpObj_dealloc, /*tp_dealloc*/

   729 	0, /*tp_print*/

   730 	(getattrfunc)0, /*tp_getattr*/

   731 	(setattrfunc)0, /*tp_setattr*/

   732 	(cmpfunc) CmpObj_compare, /*tp_compare*/

   733 	(reprfunc) CmpObj_repr, /*tp_repr*/

   734 	(PyNumberMethods *)0, /* tp_as_number */

   735 	(PySequenceMethods *)0, /* tp_as_sequence */

   736 	(PyMappingMethods *)0, /* tp_as_mapping */

   737 	(hashfunc) CmpObj_hash, /*tp_hash*/

   738 	0, /*tp_call*/

   739 	0, /*tp_str*/

   740 	PyObject_GenericGetAttr, /*tp_getattro*/

   741 	PyObject_GenericSetAttr, /*tp_setattro */

   742 	0, /*tp_as_buffer*/

   743 	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

   744 	0, /*tp_doc*/

   745 	0, /*tp_traverse*/

   746 	0, /*tp_clear*/

   747 	0, /*tp_richcompare*/

   748 	0, /*tp_weaklistoffset*/

   749 	0, /*tp_iter*/

   750 	0, /*tp_iternext*/

   751 	CmpObj_methods, /* tp_methods */

   752 	0, /*tp_members*/

   753 	CmpObj_getsetlist, /*tp_getset*/

   754 	0, /*tp_base*/

   755 	0, /*tp_dict*/

   756 	0, /*tp_descr_get*/

   757 	0, /*tp_descr_set*/

   758 	0, /*tp_dictoffset*/

   759 	CmpObj_tp_init, /* tp_init */

   760 	CmpObj_tp_alloc, /* tp_alloc */

   761 	CmpObj_tp_new, /* tp_new */

   762 	CmpObj_tp_free, /* tp_free */

   763 };

   764 

   765 /* ------------------- End object type Component -------------------- */

   766 

   767 

   768 static PyObject *Cm_RegisterComponentResource(PyObject *_self, PyObject *_args)

   769 {

   770 	PyObject *_res = NULL;

   771 	Component _rv;

   772 	ComponentResourceHandle cr;

   773 	short global;

   774 #ifndef RegisterComponentResource

   775 	PyMac_PRECHECK(RegisterComponentResource);

   776 #endif

   777 	if (!PyArg_ParseTuple(_args, "O&h",

   778 	                      ResObj_Convert, &cr,

   779 	                      &global))

   780 		return NULL;

   781 	_rv = RegisterComponentResource(cr,

   782 	                                global);

   783 	_res = Py_BuildValue("O&",

   784 	                     CmpObj_New, _rv);

   785 	return _res;

   786 }

   787 

   788 static PyObject *Cm_FindNextComponent(PyObject *_self, PyObject *_args)

   789 {

   790 	PyObject *_res = NULL;

   791 	Component _rv;

   792 	Component aComponent;

   793 	ComponentDescription looking;

   794 #ifndef FindNextComponent

   795 	PyMac_PRECHECK(FindNextComponent);

   796 #endif

   797 	if (!PyArg_ParseTuple(_args, "O&O&",

   798 	                      CmpObj_Convert, &aComponent,

   799 	                      CmpDesc_Convert, &looking))

   800 		return NULL;

   801 	_rv = FindNextComponent(aComponent,

   802 	                        &looking);

   803 	_res = Py_BuildValue("O&",

   804 	                     CmpObj_New, _rv);

   805 	return _res;

   806 }

   807 

   808 static PyObject *Cm_CountComponents(PyObject *_self, PyObject *_args)

   809 {

   810 	PyObject *_res = NULL;

   811 	long _rv;

   812 	ComponentDescription looking;

   813 #ifndef CountComponents

   814 	PyMac_PRECHECK(CountComponents);

   815 #endif

   816 	if (!PyArg_ParseTuple(_args, "O&",

   817 	                      CmpDesc_Convert, &looking))

   818 		return NULL;

   819 	_rv = CountComponents(&looking);

   820 	_res = Py_BuildValue("l",

   821 	                     _rv);

   822 	return _res;

   823 }

   824 

   825 static PyObject *Cm_GetComponentListModSeed(PyObject *_self, PyObject *_args)

   826 {

   827 	PyObject *_res = NULL;

   828 	long _rv;

   829 #ifndef GetComponentListModSeed

   830 	PyMac_PRECHECK(GetComponentListModSeed);

   831 #endif

   832 	if (!PyArg_ParseTuple(_args, ""))

   833 		return NULL;

   834 	_rv = GetComponentListModSeed();

   835 	_res = Py_BuildValue("l",

   836 	                     _rv);

   837 	return _res;

   838 }

   839 

   840 static PyObject *Cm_CloseComponentResFile(PyObject *_self, PyObject *_args)

   841 {

   842 	PyObject *_res = NULL;

   843 	OSErr _err;

   844 	short refnum;

   845 #ifndef CloseComponentResFile

   846 	PyMac_PRECHECK(CloseComponentResFile);

   847 #endif

   848 	if (!PyArg_ParseTuple(_args, "h",

   849 	                      &refnum))

   850 		return NULL;

   851 	_err = CloseComponentResFile(refnum);

   852 	if (_err != noErr) return PyMac_Error(_err);

   853 	Py_INCREF(Py_None);

   854 	_res = Py_None;

   855 	return _res;

   856 }

   857 

   858 static PyObject *Cm_OpenDefaultComponent(PyObject *_self, PyObject *_args)

   859 {

   860 	PyObject *_res = NULL;

   861 	ComponentInstance _rv;

   862 	OSType componentType;

   863 	OSType componentSubType;

   864 #ifndef OpenDefaultComponent

   865 	PyMac_PRECHECK(OpenDefaultComponent);

   866 #endif

   867 	if (!PyArg_ParseTuple(_args, "O&O&",

   868 	                      PyMac_GetOSType, &componentType,

   869 	                      PyMac_GetOSType, &componentSubType))

   870 		return NULL;

   871 	_rv = OpenDefaultComponent(componentType,

   872 	                           componentSubType);

   873 	_res = Py_BuildValue("O&",

   874 	                     CmpInstObj_New, _rv);

   875 	return _res;

   876 }

   877 

   878 static PyObject *Cm_RegisterComponentResourceFile(PyObject *_self, PyObject *_args)

   879 {

   880 	PyObject *_res = NULL;

   881 	long _rv;

   882 	short resRefNum;

   883 	short global;

   884 #ifndef RegisterComponentResourceFile

   885 	PyMac_PRECHECK(RegisterComponentResourceFile);

   886 #endif

   887 	if (!PyArg_ParseTuple(_args, "hh",

   888 	                      &resRefNum,

   889 	                      &global))

   890 		return NULL;

   891 	_rv = RegisterComponentResourceFile(resRefNum,

   892 	                                    global);

   893 	_res = Py_BuildValue("l",

   894 	                     _rv);

   895 	return _res;

   896 }

   897 

   898 static PyMethodDef Cm_methods[] = {

   899 	{"RegisterComponentResource", (PyCFunction)Cm_RegisterComponentResource, 1,

   900 	 PyDoc_STR("(ComponentResourceHandle cr, short global) -> (Component _rv)")},

   901 	{"FindNextComponent", (PyCFunction)Cm_FindNextComponent, 1,

   902 	 PyDoc_STR("(Component aComponent, ComponentDescription looking) -> (Component _rv)")},

   903 	{"CountComponents", (PyCFunction)Cm_CountComponents, 1,

   904 	 PyDoc_STR("(ComponentDescription looking) -> (long _rv)")},

   905 	{"GetComponentListModSeed", (PyCFunction)Cm_GetComponentListModSeed, 1,

   906 	 PyDoc_STR("() -> (long _rv)")},

   907 	{"CloseComponentResFile", (PyCFunction)Cm_CloseComponentResFile, 1,

   908 	 PyDoc_STR("(short refnum) -> None")},

   909 	{"OpenDefaultComponent", (PyCFunction)Cm_OpenDefaultComponent, 1,

   910 	 PyDoc_STR("(OSType componentType, OSType componentSubType) -> (ComponentInstance _rv)")},

   911 	{"RegisterComponentResourceFile", (PyCFunction)Cm_RegisterComponentResourceFile, 1,

   912 	 PyDoc_STR("(short resRefNum, short global) -> (long _rv)")},

   913 	{NULL, NULL, 0}

   914 };

   915 

   916 

   917 

   918 

   919 void init_Cm(void)

   920 {

   921 	PyObject *m;

   922 	PyObject *d;

   923 

   924 

   925 

   926 	        PyMac_INIT_TOOLBOX_OBJECT_NEW(Component, CmpObj_New);

   927 	        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Component, CmpObj_Convert);

   928 	        PyMac_INIT_TOOLBOX_OBJECT_NEW(ComponentInstance, CmpInstObj_New);

   929 	        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(ComponentInstance, CmpInstObj_Convert);

   930 

   931 

   932 	m = Py_InitModule("_Cm", Cm_methods);

   933 	d = PyModule_GetDict(m);

   934 	Cm_Error = PyMac_GetOSErrException();

   935 	if (Cm_Error == NULL ||

   936 	    PyDict_SetItemString(d, "Error", Cm_Error) != 0)

   937 		return;

   938 	ComponentInstance_Type.ob_type = &PyType_Type;

   939 	if (PyType_Ready(&ComponentInstance_Type) < 0) return;

   940 	Py_INCREF(&ComponentInstance_Type);

   941 	PyModule_AddObject(m, "ComponentInstance", (PyObject *)&ComponentInstance_Type);

   942 	/* Backward-compatible name */

   943 	Py_INCREF(&ComponentInstance_Type);

   944 	PyModule_AddObject(m, "ComponentInstanceType", (PyObject *)&ComponentInstance_Type);

   945 	Component_Type.ob_type = &PyType_Type;

   946 	if (PyType_Ready(&Component_Type) < 0) return;

   947 	Py_INCREF(&Component_Type);

   948 	PyModule_AddObject(m, "Component", (PyObject *)&Component_Type);

   949 	/* Backward-compatible name */

   950 	Py_INCREF(&Component_Type);

   951 	PyModule_AddObject(m, "ComponentType", (PyObject *)&Component_Type);

   952 }

   953 

   954 /* ========================= End module _Cm ========================= */

   955