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 *
CmpDesc_New(ComponentDescription * itself)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
CmpDesc_Convert(PyObject * v,ComponentDescription * p_itself)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
CmpInstObj_New(ComponentInstance itself)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
CmpInstObj_Convert(PyObject * v,ComponentInstance * p_itself)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
CmpInstObj_dealloc(ComponentInstanceObject * self)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
CmpInstObj_CloseComponent(ComponentInstanceObject * _self,PyObject * _args)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
CmpInstObj_GetComponentInstanceError(ComponentInstanceObject * _self,PyObject * _args)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
CmpInstObj_SetComponentInstanceError(ComponentInstanceObject * _self,PyObject * _args)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
CmpInstObj_GetComponentInstanceStorage(ComponentInstanceObject * _self,PyObject * _args)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
CmpInstObj_SetComponentInstanceStorage(ComponentInstanceObject * _self,PyObject * _args)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__
CmpInstObj_ComponentFunctionImplemented(ComponentInstanceObject * _self,PyObject * _args)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
CmpInstObj_GetComponentVersion(ComponentInstanceObject * _self,PyObject * _args)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
CmpInstObj_ComponentSetTarget(ComponentInstanceObject * _self,PyObject * _args)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
CmpInstObj_tp_new(PyTypeObject * type,PyObject * _args,PyObject * _kwds)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
CmpObj_New(Component itself)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
CmpObj_Convert(PyObject * v,Component * p_itself)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
CmpObj_dealloc(ComponentObject * self)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
CmpObj_UnregisterComponent(ComponentObject * _self,PyObject * _args)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
CmpObj_GetComponentInfo(ComponentObject * _self,PyObject * _args)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
CmpObj_OpenComponent(ComponentObject * _self,PyObject * _args)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
CmpObj_ResolveComponentAlias(ComponentObject * _self,PyObject * _args)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
CmpObj_GetComponentPublicIndString(ComponentObject * _self,PyObject * _args)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
CmpObj_GetComponentRefcon(ComponentObject * _self,PyObject * _args)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
CmpObj_SetComponentRefcon(ComponentObject * _self,PyObject * _args)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
CmpObj_OpenComponentResFile(ComponentObject * _self,PyObject * _args)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
CmpObj_GetComponentResource(ComponentObject * _self,PyObject * _args)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
CmpObj_GetComponentIndString(ComponentObject * _self,PyObject * _args)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
CmpObj_CountComponentInstances(ComponentObject * _self,PyObject * _args)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
CmpObj_SetDefaultComponent(ComponentObject * _self,PyObject * _args)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
CmpObj_CaptureComponent(ComponentObject * _self,PyObject * _args)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
CmpObj_UncaptureComponent(ComponentObject * _self,PyObject * _args)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__
CmpObj_GetComponentIconSuite(ComponentObject * _self,PyObject * _args)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
CmpObj_tp_new(PyTypeObject * type,PyObject * _args,PyObject * _kwds)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
Cm_RegisterComponentResource(PyObject * _self,PyObject * _args)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
Cm_FindNextComponent(PyObject * _self,PyObject * _args)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
Cm_CountComponents(PyObject * _self,PyObject * _args)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
Cm_GetComponentListModSeed(PyObject * _self,PyObject * _args)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
Cm_CloseComponentResFile(PyObject * _self,PyObject * _args)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
Cm_OpenDefaultComponent(PyObject * _self,PyObject * _args)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
Cm_RegisterComponentResourceFile(PyObject * _self,PyObject * _args)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
init_Cm(void)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
956