Mac/Modules/cm/Cmmodule.c

   1
   2 /* =========================== Module Cm ============================ */
   3
   4 #include "Python.h"
   5
   6
   7
   8 #define SystemSevenOrLater 1
   9
  10 #include "macglue.h"
  11 #include <Memory.h>
  12 #include <Dialogs.h>
  13 #include <Menus.h>
  14 #include <Controls.h>
  15
  16 extern PyObject *ResObj_New(Handle);
  17 extern int ResObj_Convert(PyObject *, Handle *);
  18 extern PyObject *OptResObj_New(Handle);
  19 extern int OptResObj_Convert(PyObject *, Handle *);
  20
  21 extern PyObject *WinObj_New(WindowPtr);
  22 extern int WinObj_Convert(PyObject *, WindowPtr *);
  23 extern PyTypeObject Window_Type;
  24 #define WinObj_Check(x) ((x)->ob_type == &Window_Type)
  25
  26 extern PyObject *DlgObj_New(DialogPtr);
  27 extern int DlgObj_Convert(PyObject *, DialogPtr *);
  28 extern PyTypeObject Dialog_Type;
  29 #define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
  30
  31 extern PyObject *MenuObj_New(MenuHandle);
  32 extern int MenuObj_Convert(PyObject *, MenuHandle *);
  33
  34 extern PyObject *CtlObj_New(ControlHandle);
  35 extern int CtlObj_Convert(PyObject *, ControlHandle *);
  36
  37 extern PyObject *GrafObj_New(GrafPtr);
  38 extern int GrafObj_Convert(PyObject *, GrafPtr *);
  39
  40 extern PyObject *BMObj_New(BitMapPtr);
  41 extern int BMObj_Convert(PyObject *, BitMapPtr *);
  42
  43 extern PyObject *WinObj_WhichWindow(WindowPtr);
  44
  45 #include <Components.h>
  46
  47 /*
  48 ** Parse/generate ComponentDescriptor records
  49 */
  50 PyObject *CmpDesc_New(itself)
  51         ComponentDescription *itself;
  52 {
  53
  54         return Py_BuildValue("O&O&O&ll",
  55                 PyMac_BuildOSType, itself->componentType,
  56                 PyMac_BuildOSType, itself->componentSubType,
  57                 PyMac_BuildOSType, itself->componentManufacturer,
  58                 itself->componentFlags, itself->componentFlagsMask);
  59 }
  60
  61 CmpDesc_Convert(v, p_itself)
  62         PyObject *v;
  63         ComponentDescription *p_itself;
  64 {
  65         return PyArg_ParseTuple(v, "O&O&O&ll",
  66                 PyMac_GetOSType, &p_itself->componentType,
  67                 PyMac_GetOSType, &p_itself->componentSubType,
  68                 PyMac_GetOSType, &p_itself->componentManufacturer,
  69                 &p_itself->componentFlags, &p_itself->componentFlagsMask);
  70 }
  71
  72
  73 static PyObject *Cm_Error;
  74
  75 /* ----------------- Object type ComponentInstance ------------------ */
  76
  77 PyTypeObject ComponentInstance_Type;
  78
  79 #define CmpInstObj_Check(x) ((x)->ob_type == &ComponentInstance_Type)
  80
  81 typedef struct ComponentInstanceObject {
  82         PyObject_HEAD
  83         ComponentInstance ob_itself;
  84 } ComponentInstanceObject;
  85
  86 PyObject *CmpInstObj_New(itself)
  87         ComponentInstance itself;
  88 {
  89         ComponentInstanceObject *it;
  90         if (itself == NULL) {
  91                                                 PyErr_SetString(Cm_Error,"NULL ComponentInstance");
  92                                                 return NULL;
  93                                         }
  94         it = PyObject_NEW(ComponentInstanceObject, &ComponentInstance_Type);
  95         if (it == NULL) return NULL;
  96         it->ob_itself = itself;
  97         return (PyObject *)it;
  98 }
  99 CmpInstObj_Convert(v, p_itself)
 100         PyObject *v;
 101         ComponentInstance *p_itself;
 102 {
 103         if (!CmpInstObj_Check(v))
 104         {
 105                 PyErr_SetString(PyExc_TypeError, "ComponentInstance required");
 106                 return 0;
 107         }
 108         *p_itself = ((ComponentInstanceObject *)v)->ob_itself;
 109         return 1;
 110 }
 111
 112 static void CmpInstObj_dealloc(self)
 113         ComponentInstanceObject *self;
 114 {
 115         /* Cleanup of self->ob_itself goes here */
 116         PyMem_DEL(self);
 117 }
 118
 119 static PyObject *CmpInstObj_CloseComponent(_self, _args)
 120         ComponentInstanceObject *_self;
 121         PyObject *_args;
 122 {
 123         PyObject *_res = NULL;
 124         OSErr _err;
 125         if (!PyArg_ParseTuple(_args, ""))
 126                 return NULL;
 127         _err = CloseComponent(_self->ob_itself);
 128         if (_err != noErr) return PyMac_Error(_err);
 129         Py_INCREF(Py_None);
 130         _res = Py_None;
 131         return _res;
 132 }
 133
 134 static PyObject *CmpInstObj_GetComponentInstanceError(_self, _args)
 135         ComponentInstanceObject *_self;
 136         PyObject *_args;
 137 {
 138         PyObject *_res = NULL;
 139         OSErr _err;
 140         if (!PyArg_ParseTuple(_args, ""))
 141                 return NULL;
 142         _err = GetComponentInstanceError(_self->ob_itself);
 143         if (_err != noErr) return PyMac_Error(_err);
 144         Py_INCREF(Py_None);
 145         _res = Py_None;
 146         return _res;
 147 }
 148
 149 static PyObject *CmpInstObj_ComponentFunctionImplemented(_self, _args)
 150         ComponentInstanceObject *_self;
 151         PyObject *_args;
 152 {
 153         PyObject *_res = NULL;
 154         long _rv;
 155         short ftnNumber;
 156         if (!PyArg_ParseTuple(_args, "h",
 157                               &ftnNumber))
 158                 return NULL;
 159         _rv = ComponentFunctionImplemented(_self->ob_itself,
 160                                            ftnNumber);
 161         _res = Py_BuildValue("l",
 162                              _rv);
 163         return _res;
 164 }
 165
 166 static PyObject *CmpInstObj_GetComponentVersion(_self, _args)
 167         ComponentInstanceObject *_self;
 168         PyObject *_args;
 169 {
 170         PyObject *_res = NULL;
 171         long _rv;
 172         if (!PyArg_ParseTuple(_args, ""))
 173                 return NULL;
 174         _rv = GetComponentVersion(_self->ob_itself);
 175         _res = Py_BuildValue("l",
 176                              _rv);
 177         return _res;
 178 }
 179
 180 static PyObject *CmpInstObj_ComponentSetTarget(_self, _args)
 181         ComponentInstanceObject *_self;
 182         PyObject *_args;
 183 {
 184         PyObject *_res = NULL;
 185         long _rv;
 186         ComponentInstance target;
 187         if (!PyArg_ParseTuple(_args, "O&",
 188                               CmpInstObj_Convert, &target))
 189                 return NULL;
 190         _rv = ComponentSetTarget(_self->ob_itself,
 191                                  target);
 192         _res = Py_BuildValue("l",
 193                              _rv);
 194         return _res;
 195 }
 196
 197 static PyObject *CmpInstObj_SetComponentInstanceError(_self, _args)
 198         ComponentInstanceObject *_self;
 199         PyObject *_args;
 200 {
 201         PyObject *_res = NULL;
 202         OSErr theError;
 203         if (!PyArg_ParseTuple(_args, "h",
 204                               &theError))
 205                 return NULL;
 206         SetComponentInstanceError(_self->ob_itself,
 207                                   theError);
 208         Py_INCREF(Py_None);
 209         _res = Py_None;
 210         return _res;
 211 }
 212
 213 static PyObject *CmpInstObj_GetComponentInstanceStorage(_self, _args)
 214         ComponentInstanceObject *_self;
 215         PyObject *_args;
 216 {
 217         PyObject *_res = NULL;
 218         Handle _rv;
 219         if (!PyArg_ParseTuple(_args, ""))
 220                 return NULL;
 221         _rv = GetComponentInstanceStorage(_self->ob_itself);
 222         _res = Py_BuildValue("O&",
 223                              ResObj_New, _rv);
 224         return _res;
 225 }
 226
 227 static PyObject *CmpInstObj_SetComponentInstanceStorage(_self, _args)
 228         ComponentInstanceObject *_self;
 229         PyObject *_args;
 230 {
 231         PyObject *_res = NULL;
 232         Handle theStorage;
 233         if (!PyArg_ParseTuple(_args, "O&",
 234                               ResObj_Convert, &theStorage))
 235                 return NULL;
 236         SetComponentInstanceStorage(_self->ob_itself,
 237                                     theStorage);
 238         Py_INCREF(Py_None);
 239         _res = Py_None;
 240         return _res;
 241 }
 242
 243 static PyObject *CmpInstObj_GetComponentInstanceA5(_self, _args)
 244         ComponentInstanceObject *_self;
 245         PyObject *_args;
 246 {
 247         PyObject *_res = NULL;
 248         long _rv;
 249         if (!PyArg_ParseTuple(_args, ""))
 250                 return NULL;
 251         _rv = GetComponentInstanceA5(_self->ob_itself);
 252         _res = Py_BuildValue("l",
 253                              _rv);
 254         return _res;
 255 }
 256
 257 static PyObject *CmpInstObj_SetComponentInstanceA5(_self, _args)
 258         ComponentInstanceObject *_self;
 259         PyObject *_args;
 260 {
 261         PyObject *_res = NULL;
 262         long theA5;
 263         if (!PyArg_ParseTuple(_args, "l",
 264                               &theA5))
 265                 return NULL;
 266         SetComponentInstanceA5(_self->ob_itself,
 267                                theA5);
 268         Py_INCREF(Py_None);
 269         _res = Py_None;
 270         return _res;
 271 }
 272
 273 static PyMethodDef CmpInstObj_methods[] = {
 274         {"CloseComponent", (PyCFunction)CmpInstObj_CloseComponent, 1,
 275          "() -> None"},
 276         {"GetComponentInstanceError", (PyCFunction)CmpInstObj_GetComponentInstanceError, 1,
 277          "() -> None"},
 278         {"ComponentFunctionImplemented", (PyCFunction)CmpInstObj_ComponentFunctionImplemented, 1,
 279          "(short ftnNumber) -> (long _rv)"},
 280         {"GetComponentVersion", (PyCFunction)CmpInstObj_GetComponentVersion, 1,
 281          "() -> (long _rv)"},
 282         {"ComponentSetTarget", (PyCFunction)CmpInstObj_ComponentSetTarget, 1,
 283          "(ComponentInstance target) -> (long _rv)"},
 284         {"SetComponentInstanceError", (PyCFunction)CmpInstObj_SetComponentInstanceError, 1,
 285          "(OSErr theError) -> None"},
 286         {"GetComponentInstanceStorage", (PyCFunction)CmpInstObj_GetComponentInstanceStorage, 1,
 287          "() -> (Handle _rv)"},
 288         {"SetComponentInstanceStorage", (PyCFunction)CmpInstObj_SetComponentInstanceStorage, 1,
 289          "(Handle theStorage) -> None"},
 290         {"GetComponentInstanceA5", (PyCFunction)CmpInstObj_GetComponentInstanceA5, 1,
 291          "() -> (long _rv)"},
 292         {"SetComponentInstanceA5", (PyCFunction)CmpInstObj_SetComponentInstanceA5, 1,
 293          "(long theA5) -> None"},
 294         {NULL, NULL, 0}
 295 };
 296
 297 PyMethodChain CmpInstObj_chain = { CmpInstObj_methods, NULL };
 298
 299 static PyObject *CmpInstObj_getattr(self, name)
 300         ComponentInstanceObject *self;
 301         char *name;
 302 {
 303         return Py_FindMethodInChain(&CmpInstObj_chain, (PyObject *)self, name);
 304 }
 305
 306 #define CmpInstObj_setattr NULL
 307
 308 PyTypeObject ComponentInstance_Type = {
 309         PyObject_HEAD_INIT(&PyType_Type)
 310         0, /*ob_size*/
 311         "ComponentInstance", /*tp_name*/
 312         sizeof(ComponentInstanceObject), /*tp_basicsize*/
 313         0, /*tp_itemsize*/
 314         /* methods */
 315         (destructor) CmpInstObj_dealloc, /*tp_dealloc*/
 316         0, /*tp_print*/
 317         (getattrfunc) CmpInstObj_getattr, /*tp_getattr*/
 318         (setattrfunc) CmpInstObj_setattr, /*tp_setattr*/
 319 };
 320
 321 /* --------------- End object type ComponentInstance ---------------- */
 322
 323
 324 /* --------------------- Object type Component ---------------------- */
 325
 326 PyTypeObject Component_Type;
 327
 328 #define CmpObj_Check(x) ((x)->ob_type == &Component_Type)
 329
 330 typedef struct ComponentObject {
 331         PyObject_HEAD
 332         Component ob_itself;
 333 } ComponentObject;
 334
 335 PyObject *CmpObj_New(itself)
 336         Component itself;
 337 {
 338         ComponentObject *it;
 339         if (itself == NULL) {
 340                                                 /* XXXX Or should we return None? */
 341                                                 PyErr_SetString(Cm_Error,"No such component");
 342                                                 return NULL;
 343                                         }
 344         it = PyObject_NEW(ComponentObject, &Component_Type);
 345         if (it == NULL) return NULL;
 346         it->ob_itself = itself;
 347         return (PyObject *)it;
 348 }
 349 CmpObj_Convert(v, p_itself)
 350         PyObject *v;
 351         Component *p_itself;
 352 {
 353         if ( v == Py_None ) {
 354                                                 *p_itself = 0;
 355                                                 return 1;
 356                         }
 357         if (!CmpObj_Check(v))
 358         {
 359                 PyErr_SetString(PyExc_TypeError, "Component required");
 360                 return 0;
 361         }
 362         *p_itself = ((ComponentObject *)v)->ob_itself;
 363         return 1;
 364 }
 365
 366 static void CmpObj_dealloc(self)
 367         ComponentObject *self;
 368 {
 369         /* Cleanup of self->ob_itself goes here */
 370         PyMem_DEL(self);
 371 }
 372
 373 static PyObject *CmpObj_UnregisterComponent(_self, _args)
 374         ComponentObject *_self;
 375         PyObject *_args;
 376 {
 377         PyObject *_res = NULL;
 378         OSErr _err;
 379         if (!PyArg_ParseTuple(_args, ""))
 380                 return NULL;
 381         _err = UnregisterComponent(_self->ob_itself);
 382         if (_err != noErr) return PyMac_Error(_err);
 383         Py_INCREF(Py_None);
 384         _res = Py_None;
 385         return _res;
 386 }
 387
 388 static PyObject *CmpObj_GetComponentInfo(_self, _args)
 389         ComponentObject *_self;
 390         PyObject *_args;
 391 {
 392         PyObject *_res = NULL;
 393         OSErr _err;
 394         ComponentDescription cd;
 395         Handle componentName;
 396         Handle componentInfo;
 397         Handle componentIcon;
 398         if (!PyArg_ParseTuple(_args, "O&O&O&",
 399                               ResObj_Convert, &componentName,
 400                               ResObj_Convert, &componentInfo,
 401                               ResObj_Convert, &componentIcon))
 402                 return NULL;
 403         _err = GetComponentInfo(_self->ob_itself,
 404                                 &cd,
 405                                 componentName,
 406                                 componentInfo,
 407                                 componentIcon);
 408         if (_err != noErr) return PyMac_Error(_err);
 409         _res = Py_BuildValue("O&",
 410                              CmpDesc_New, &cd);
 411         return _res;
 412 }
 413
 414 static PyObject *CmpObj_OpenComponent(_self, _args)
 415         ComponentObject *_self;
 416         PyObject *_args;
 417 {
 418         PyObject *_res = NULL;
 419         ComponentInstance _rv;
 420         if (!PyArg_ParseTuple(_args, ""))
 421                 return NULL;
 422         _rv = OpenComponent(_self->ob_itself);
 423         _res = Py_BuildValue("O&",
 424                              CmpInstObj_New, _rv);
 425         return _res;
 426 }
 427
 428 static PyObject *CmpObj_GetComponentRefcon(_self, _args)
 429         ComponentObject *_self;
 430         PyObject *_args;
 431 {
 432         PyObject *_res = NULL;
 433         long _rv;
 434         if (!PyArg_ParseTuple(_args, ""))
 435                 return NULL;
 436         _rv = GetComponentRefcon(_self->ob_itself);
 437         _res = Py_BuildValue("l",
 438                              _rv);
 439         return _res;
 440 }
 441
 442 static PyObject *CmpObj_SetComponentRefcon(_self, _args)
 443         ComponentObject *_self;
 444         PyObject *_args;
 445 {
 446         PyObject *_res = NULL;
 447         long theRefcon;
 448         if (!PyArg_ParseTuple(_args, "l",
 449                               &theRefcon))
 450                 return NULL;
 451         SetComponentRefcon(_self->ob_itself,
 452                            theRefcon);
 453         Py_INCREF(Py_None);
 454         _res = Py_None;
 455         return _res;
 456 }
 457
 458 static PyObject *CmpObj_OpenComponentResFile(_self, _args)
 459         ComponentObject *_self;
 460         PyObject *_args;
 461 {
 462         PyObject *_res = NULL;
 463         short _rv;
 464         if (!PyArg_ParseTuple(_args, ""))
 465                 return NULL;
 466         _rv = OpenComponentResFile(_self->ob_itself);
 467         _res = Py_BuildValue("h",
 468                              _rv);
 469         return _res;
 470 }
 471
 472 static PyObject *CmpObj_CountComponentInstances(_self, _args)
 473         ComponentObject *_self;
 474         PyObject *_args;
 475 {
 476         PyObject *_res = NULL;
 477         long _rv;
 478         if (!PyArg_ParseTuple(_args, ""))
 479                 return NULL;
 480         _rv = CountComponentInstances(_self->ob_itself);
 481         _res = Py_BuildValue("l",
 482                              _rv);
 483         return _res;
 484 }
 485
 486 static PyObject *CmpObj_SetDefaultComponent(_self, _args)
 487         ComponentObject *_self;
 488         PyObject *_args;
 489 {
 490         PyObject *_res = NULL;
 491         OSErr _err;
 492         short flags;
 493         if (!PyArg_ParseTuple(_args, "h",
 494                               &flags))
 495                 return NULL;
 496         _err = SetDefaultComponent(_self->ob_itself,
 497                                    flags);
 498         if (_err != noErr) return PyMac_Error(_err);
 499         Py_INCREF(Py_None);
 500         _res = Py_None;
 501         return _res;
 502 }
 503
 504 static PyObject *CmpObj_CaptureComponent(_self, _args)
 505         ComponentObject *_self;
 506         PyObject *_args;
 507 {
 508         PyObject *_res = NULL;
 509         Component _rv;
 510         Component capturingComponent;
 511         if (!PyArg_ParseTuple(_args, "O&",
 512                               CmpObj_Convert, &capturingComponent))
 513                 return NULL;
 514         _rv = CaptureComponent(_self->ob_itself,
 515                                capturingComponent);
 516         _res = Py_BuildValue("O&",
 517                              CmpObj_New, _rv);
 518         return _res;
 519 }
 520
 521 static PyObject *CmpObj_UncaptureComponent(_self, _args)
 522         ComponentObject *_self;
 523         PyObject *_args;
 524 {
 525         PyObject *_res = NULL;
 526         OSErr _err;
 527         if (!PyArg_ParseTuple(_args, ""))
 528                 return NULL;
 529         _err = UncaptureComponent(_self->ob_itself);
 530         if (_err != noErr) return PyMac_Error(_err);
 531         Py_INCREF(Py_None);
 532         _res = Py_None;
 533         return _res;
 534 }
 535
 536 static PyObject *CmpObj_GetComponentIconSuite(_self, _args)
 537         ComponentObject *_self;
 538         PyObject *_args;
 539 {
 540         PyObject *_res = NULL;
 541         OSErr _err;
 542         Handle iconSuite;
 543         if (!PyArg_ParseTuple(_args, ""))
 544                 return NULL;
 545         _err = GetComponentIconSuite(_self->ob_itself,
 546                                      &iconSuite);
 547         if (_err != noErr) return PyMac_Error(_err);
 548         _res = Py_BuildValue("O&",
 549                              ResObj_New, iconSuite);
 550         return _res;
 551 }
 552
 553 static PyMethodDef CmpObj_methods[] = {
 554         {"UnregisterComponent", (PyCFunction)CmpObj_UnregisterComponent, 1,
 555          "() -> None"},
 556         {"GetComponentInfo", (PyCFunction)CmpObj_GetComponentInfo, 1,
 557          "(Handle componentName, Handle componentInfo, Handle componentIcon) -> (ComponentDescription cd)"},
 558         {"OpenComponent", (PyCFunction)CmpObj_OpenComponent, 1,
 559          "() -> (ComponentInstance _rv)"},
 560         {"GetComponentRefcon", (PyCFunction)CmpObj_GetComponentRefcon, 1,
 561          "() -> (long _rv)"},
 562         {"SetComponentRefcon", (PyCFunction)CmpObj_SetComponentRefcon, 1,
 563          "(long theRefcon) -> None"},
 564         {"OpenComponentResFile", (PyCFunction)CmpObj_OpenComponentResFile, 1,
 565          "() -> (short _rv)"},
 566         {"CountComponentInstances", (PyCFunction)CmpObj_CountComponentInstances, 1,
 567          "() -> (long _rv)"},
 568         {"SetDefaultComponent", (PyCFunction)CmpObj_SetDefaultComponent, 1,
 569          "(short flags) -> None"},
 570         {"CaptureComponent", (PyCFunction)CmpObj_CaptureComponent, 1,
 571          "(Component capturingComponent) -> (Component _rv)"},
 572         {"UncaptureComponent", (PyCFunction)CmpObj_UncaptureComponent, 1,
 573          "() -> None"},
 574         {"GetComponentIconSuite", (PyCFunction)CmpObj_GetComponentIconSuite, 1,
 575          "() -> (Handle iconSuite)"},
 576         {NULL, NULL, 0}
 577 };
 578
 579 PyMethodChain CmpObj_chain = { CmpObj_methods, NULL };
 580
 581 static PyObject *CmpObj_getattr(self, name)
 582         ComponentObject *self;
 583         char *name;
 584 {
 585         return Py_FindMethodInChain(&CmpObj_chain, (PyObject *)self, name);
 586 }
 587
 588 #define CmpObj_setattr NULL
 589
 590 PyTypeObject Component_Type = {
 591         PyObject_HEAD_INIT(&PyType_Type)
 592         0, /*ob_size*/
 593         "Component", /*tp_name*/
 594         sizeof(ComponentObject), /*tp_basicsize*/
 595         0, /*tp_itemsize*/
 596         /* methods */
 597         (destructor) CmpObj_dealloc, /*tp_dealloc*/
 598         0, /*tp_print*/
 599         (getattrfunc) CmpObj_getattr, /*tp_getattr*/
 600         (setattrfunc) CmpObj_setattr, /*tp_setattr*/
 601 };
 602
 603 /* ------------------- End object type Component -------------------- */
 604
 605
 606 static PyObject *Cm_RegisterComponentResource(_self, _args)
 607         PyObject *_self;
 608         PyObject *_args;
 609 {
 610         PyObject *_res = NULL;
 611         Component _rv;
 612         ComponentResourceHandle tr;
 613         short global;
 614         if (!PyArg_ParseTuple(_args, "O&h",
 615                               ResObj_Convert, &tr,
 616                               &global))
 617                 return NULL;
 618         _rv = RegisterComponentResource(tr,
 619                                         global);
 620         _res = Py_BuildValue("O&",
 621                              CmpObj_New, _rv);
 622         return _res;
 623 }
 624
 625 static PyObject *Cm_FindNextComponent(_self, _args)
 626         PyObject *_self;
 627         PyObject *_args;
 628 {
 629         PyObject *_res = NULL;
 630         Component _rv;
 631         Component aComponent;
 632         ComponentDescription looking;
 633         if (!PyArg_ParseTuple(_args, "O&O&",
 634                               CmpObj_Convert, &aComponent,
 635                               CmpDesc_Convert, &looking))
 636                 return NULL;
 637         _rv = FindNextComponent(aComponent,
 638                                 &looking);
 639         _res = Py_BuildValue("O&",
 640                              CmpObj_New, _rv);
 641         return _res;
 642 }
 643
 644 static PyObject *Cm_CountComponents(_self, _args)
 645         PyObject *_self;
 646         PyObject *_args;
 647 {
 648         PyObject *_res = NULL;
 649         long _rv;
 650         ComponentDescription looking;
 651         if (!PyArg_ParseTuple(_args, "O&",
 652                               CmpDesc_Convert, &looking))
 653                 return NULL;
 654         _rv = CountComponents(&looking);
 655         _res = Py_BuildValue("l",
 656                              _rv);
 657         return _res;
 658 }
 659
 660 static PyObject *Cm_GetComponentListModSeed(_self, _args)
 661         PyObject *_self;
 662         PyObject *_args;
 663 {
 664         PyObject *_res = NULL;
 665         long _rv;
 666         if (!PyArg_ParseTuple(_args, ""))
 667                 return NULL;
 668         _rv = GetComponentListModSeed();
 669         _res = Py_BuildValue("l",
 670                              _rv);
 671         return _res;
 672 }
 673
 674 static PyObject *Cm_CloseComponentResFile(_self, _args)
 675         PyObject *_self;
 676         PyObject *_args;
 677 {
 678         PyObject *_res = NULL;
 679         OSErr _err;
 680         short refnum;
 681         if (!PyArg_ParseTuple(_args, "h",
 682                               &refnum))
 683                 return NULL;
 684         _err = CloseComponentResFile(refnum);
 685         if (_err != noErr) return PyMac_Error(_err);
 686         Py_INCREF(Py_None);
 687         _res = Py_None;
 688         return _res;
 689 }
 690
 691 static PyObject *Cm_OpenDefaultComponent(_self, _args)
 692         PyObject *_self;
 693         PyObject *_args;
 694 {
 695         PyObject *_res = NULL;
 696         ComponentInstance _rv;
 697         OSType componentType;
 698         OSType componentSubType;
 699         if (!PyArg_ParseTuple(_args, "O&O&",
 700                               PyMac_GetOSType, &componentType,
 701                               PyMac_GetOSType, &componentSubType))
 702                 return NULL;
 703         _rv = OpenDefaultComponent(componentType,
 704                                    componentSubType);
 705         _res = Py_BuildValue("O&",
 706                              CmpInstObj_New, _rv);
 707         return _res;
 708 }
 709
 710 static PyObject *Cm_RegisterComponentResourceFile(_self, _args)
 711         PyObject *_self;
 712         PyObject *_args;
 713 {
 714         PyObject *_res = NULL;
 715         long _rv;
 716         short resRefNum;
 717         short global;
 718         if (!PyArg_ParseTuple(_args, "hh",
 719                               &resRefNum,
 720                               &global))
 721                 return NULL;
 722         _rv = RegisterComponentResourceFile(resRefNum,
 723                                             global);
 724         _res = Py_BuildValue("l",
 725                              _rv);
 726         return _res;
 727 }
 728
 729 static PyMethodDef Cm_methods[] = {
 730         {"RegisterComponentResource", (PyCFunction)Cm_RegisterComponentResource, 1,
 731          "(ComponentResourceHandle tr, short global) -> (Component _rv)"},
 732         {"FindNextComponent", (PyCFunction)Cm_FindNextComponent, 1,
 733          "(Component aComponent, ComponentDescription looking) -> (Component _rv)"},
 734         {"CountComponents", (PyCFunction)Cm_CountComponents, 1,
 735          "(ComponentDescription looking) -> (long _rv)"},
 736         {"GetComponentListModSeed", (PyCFunction)Cm_GetComponentListModSeed, 1,
 737          "() -> (long _rv)"},
 738         {"CloseComponentResFile", (PyCFunction)Cm_CloseComponentResFile, 1,
 739          "(short refnum) -> None"},
 740         {"OpenDefaultComponent", (PyCFunction)Cm_OpenDefaultComponent, 1,
 741          "(OSType componentType, OSType componentSubType) -> (ComponentInstance _rv)"},
 742         {"RegisterComponentResourceFile", (PyCFunction)Cm_RegisterComponentResourceFile, 1,
 743          "(short resRefNum, short global) -> (long _rv)"},
 744         {NULL, NULL, 0}
 745 };
 746
 747
 748
 749
 750 void initCm()
 751 {
 752         PyObject *m;
 753         PyObject *d;
 754
 755
 756
 757
 758         m = Py_InitModule("Cm", Cm_methods);
 759         d = PyModule_GetDict(m);
 760         Cm_Error = PyMac_GetOSErrException();
 761         if (Cm_Error == NULL ||
 762             PyDict_SetItemString(d, "Error", Cm_Error) != 0)
 763                 Py_FatalError("can't initialize Cm.Error");
 764 }
 765
 766 /* ========================= End module Cm ========================== */
 767