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 956