home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Python 1.4 / Python 1.4 source / Mac / Modules / list / Listmodule.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-31  |  15.8 KB  |  680 lines  |  [TEXT/CWIE]
  1.  
  2. /* ========================== Module List =========================== */
  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 <Lists.h>
  46.  
  47. static PyObject *List_Error;
  48.  
  49. /* ------------------------ Object type List ------------------------ */
  50.  
  51. PyTypeObject List_Type;
  52.  
  53. #define ListObj_Check(x) ((x)->ob_type == &List_Type)
  54.  
  55. typedef struct ListObject {
  56.     PyObject_HEAD
  57.     ListRef ob_itself;
  58. } ListObject;
  59.  
  60. PyObject *ListObj_New(itself)
  61.     ListRef itself;
  62. {
  63.     ListObject *it;
  64.     if (itself == NULL) {
  65.                         PyErr_SetString(List_Error,"Cannot create null List");
  66.                         return NULL;
  67.                     }
  68.     it = PyObject_NEW(ListObject, &List_Type);
  69.     if (it == NULL) return NULL;
  70.     it->ob_itself = itself;
  71.     return (PyObject *)it;
  72. }
  73. ListObj_Convert(v, p_itself)
  74.     PyObject *v;
  75.     ListRef *p_itself;
  76. {
  77.     if (!ListObj_Check(v))
  78.     {
  79.         PyErr_SetString(PyExc_TypeError, "List required");
  80.         return 0;
  81.     }
  82.     *p_itself = ((ListObject *)v)->ob_itself;
  83.     return 1;
  84. }
  85.  
  86. static void ListObj_dealloc(self)
  87.     ListObject *self;
  88. {
  89.     LDispose(self->ob_itself);
  90.     PyMem_DEL(self);
  91. }
  92.  
  93. static PyObject *ListObj_LAddColumn(_self, _args)
  94.     ListObject *_self;
  95.     PyObject *_args;
  96. {
  97.     PyObject *_res = NULL;
  98.     short _rv;
  99.     short count;
  100.     short colNum;
  101.     if (!PyArg_ParseTuple(_args, "hh",
  102.                           &count,
  103.                           &colNum))
  104.         return NULL;
  105.     _rv = LAddColumn(count,
  106.                      colNum,
  107.                      _self->ob_itself);
  108.     _res = Py_BuildValue("h",
  109.                          _rv);
  110.     return _res;
  111. }
  112.  
  113. static PyObject *ListObj_LAddRow(_self, _args)
  114.     ListObject *_self;
  115.     PyObject *_args;
  116. {
  117.     PyObject *_res = NULL;
  118.     short _rv;
  119.     short count;
  120.     short rowNum;
  121.     if (!PyArg_ParseTuple(_args, "hh",
  122.                           &count,
  123.                           &rowNum))
  124.         return NULL;
  125.     _rv = LAddRow(count,
  126.                   rowNum,
  127.                   _self->ob_itself);
  128.     _res = Py_BuildValue("h",
  129.                          _rv);
  130.     return _res;
  131. }
  132.  
  133. static PyObject *ListObj_LDelColumn(_self, _args)
  134.     ListObject *_self;
  135.     PyObject *_args;
  136. {
  137.     PyObject *_res = NULL;
  138.     short count;
  139.     short colNum;
  140.     if (!PyArg_ParseTuple(_args, "hh",
  141.                           &count,
  142.                           &colNum))
  143.         return NULL;
  144.     LDelColumn(count,
  145.                colNum,
  146.                _self->ob_itself);
  147.     Py_INCREF(Py_None);
  148.     _res = Py_None;
  149.     return _res;
  150. }
  151.  
  152. static PyObject *ListObj_LDelRow(_self, _args)
  153.     ListObject *_self;
  154.     PyObject *_args;
  155. {
  156.     PyObject *_res = NULL;
  157.     short count;
  158.     short rowNum;
  159.     if (!PyArg_ParseTuple(_args, "hh",
  160.                           &count,
  161.                           &rowNum))
  162.         return NULL;
  163.     LDelRow(count,
  164.             rowNum,
  165.             _self->ob_itself);
  166.     Py_INCREF(Py_None);
  167.     _res = Py_None;
  168.     return _res;
  169. }
  170.  
  171. static PyObject *ListObj_LGetSelect(_self, _args)
  172.     ListObject *_self;
  173.     PyObject *_args;
  174. {
  175.     PyObject *_res = NULL;
  176.     Boolean _rv;
  177.     Boolean next;
  178.     Point theCell;
  179.     if (!PyArg_ParseTuple(_args, "bO&",
  180.                           &next,
  181.                           PyMac_GetPoint, &theCell))
  182.         return NULL;
  183.     _rv = LGetSelect(next,
  184.                      &theCell,
  185.                      _self->ob_itself);
  186.     _res = Py_BuildValue("bO&",
  187.                          _rv,
  188.                          PyMac_BuildPoint, theCell);
  189.     return _res;
  190. }
  191.  
  192. static PyObject *ListObj_LLastClick(_self, _args)
  193.     ListObject *_self;
  194.     PyObject *_args;
  195. {
  196.     PyObject *_res = NULL;
  197.     Point _rv;
  198.     if (!PyArg_ParseTuple(_args, ""))
  199.         return NULL;
  200.     _rv = LLastClick(_self->ob_itself);
  201.     _res = Py_BuildValue("O&",
  202.                          PyMac_BuildPoint, _rv);
  203.     return _res;
  204. }
  205.  
  206. static PyObject *ListObj_LNextCell(_self, _args)
  207.     ListObject *_self;
  208.     PyObject *_args;
  209. {
  210.     PyObject *_res = NULL;
  211.     Boolean _rv;
  212.     Boolean hNext;
  213.     Boolean vNext;
  214.     Point theCell;
  215.     if (!PyArg_ParseTuple(_args, "bbO&",
  216.                           &hNext,
  217.                           &vNext,
  218.                           PyMac_GetPoint, &theCell))
  219.         return NULL;
  220.     _rv = LNextCell(hNext,
  221.                     vNext,
  222.                     &theCell,
  223.                     _self->ob_itself);
  224.     _res = Py_BuildValue("bO&",
  225.                          _rv,
  226.                          PyMac_BuildPoint, theCell);
  227.     return _res;
  228. }
  229.  
  230. static PyObject *ListObj_LSize(_self, _args)
  231.     ListObject *_self;
  232.     PyObject *_args;
  233. {
  234.     PyObject *_res = NULL;
  235.     short listWidth;
  236.     short listHeight;
  237.     if (!PyArg_ParseTuple(_args, "hh",
  238.                           &listWidth,
  239.                           &listHeight))
  240.         return NULL;
  241.     LSize(listWidth,
  242.           listHeight,
  243.           _self->ob_itself);
  244.     Py_INCREF(Py_None);
  245.     _res = Py_None;
  246.     return _res;
  247. }
  248.  
  249. static PyObject *ListObj_LSetDrawingMode(_self, _args)
  250.     ListObject *_self;
  251.     PyObject *_args;
  252. {
  253.     PyObject *_res = NULL;
  254.     Boolean drawIt;
  255.     if (!PyArg_ParseTuple(_args, "b",
  256.                           &drawIt))
  257.         return NULL;
  258.     LSetDrawingMode(drawIt,
  259.                     _self->ob_itself);
  260.     Py_INCREF(Py_None);
  261.     _res = Py_None;
  262.     return _res;
  263. }
  264.  
  265. static PyObject *ListObj_LScroll(_self, _args)
  266.     ListObject *_self;
  267.     PyObject *_args;
  268. {
  269.     PyObject *_res = NULL;
  270.     short dCols;
  271.     short dRows;
  272.     if (!PyArg_ParseTuple(_args, "hh",
  273.                           &dCols,
  274.                           &dRows))
  275.         return NULL;
  276.     LScroll(dCols,
  277.             dRows,
  278.             _self->ob_itself);
  279.     Py_INCREF(Py_None);
  280.     _res = Py_None;
  281.     return _res;
  282. }
  283.  
  284. static PyObject *ListObj_LAutoScroll(_self, _args)
  285.     ListObject *_self;
  286.     PyObject *_args;
  287. {
  288.     PyObject *_res = NULL;
  289.     if (!PyArg_ParseTuple(_args, ""))
  290.         return NULL;
  291.     LAutoScroll(_self->ob_itself);
  292.     Py_INCREF(Py_None);
  293.     _res = Py_None;
  294.     return _res;
  295. }
  296.  
  297. static PyObject *ListObj_LUpdate(_self, _args)
  298.     ListObject *_self;
  299.     PyObject *_args;
  300. {
  301.     PyObject *_res = NULL;
  302.     RgnHandle theRgn;
  303.     if (!PyArg_ParseTuple(_args, "O&",
  304.                           ResObj_Convert, &theRgn))
  305.         return NULL;
  306.     LUpdate(theRgn,
  307.             _self->ob_itself);
  308.     Py_INCREF(Py_None);
  309.     _res = Py_None;
  310.     return _res;
  311. }
  312.  
  313. static PyObject *ListObj_LActivate(_self, _args)
  314.     ListObject *_self;
  315.     PyObject *_args;
  316. {
  317.     PyObject *_res = NULL;
  318.     Boolean act;
  319.     if (!PyArg_ParseTuple(_args, "b",
  320.                           &act))
  321.         return NULL;
  322.     LActivate(act,
  323.               _self->ob_itself);
  324.     Py_INCREF(Py_None);
  325.     _res = Py_None;
  326.     return _res;
  327. }
  328.  
  329. static PyObject *ListObj_LCellSize(_self, _args)
  330.     ListObject *_self;
  331.     PyObject *_args;
  332. {
  333.     PyObject *_res = NULL;
  334.     Point cSize;
  335.     if (!PyArg_ParseTuple(_args, "O&",
  336.                           PyMac_GetPoint, &cSize))
  337.         return NULL;
  338.     LCellSize(cSize,
  339.               _self->ob_itself);
  340.     Py_INCREF(Py_None);
  341.     _res = Py_None;
  342.     return _res;
  343. }
  344.  
  345. static PyObject *ListObj_LClick(_self, _args)
  346.     ListObject *_self;
  347.     PyObject *_args;
  348. {
  349.     PyObject *_res = NULL;
  350.     Boolean _rv;
  351.     Point pt;
  352.     short modifiers;
  353.     if (!PyArg_ParseTuple(_args, "O&h",
  354.                           PyMac_GetPoint, &pt,
  355.                           &modifiers))
  356.         return NULL;
  357.     _rv = LClick(pt,
  358.                  modifiers,
  359.                  _self->ob_itself);
  360.     _res = Py_BuildValue("b",
  361.                          _rv);
  362.     return _res;
  363. }
  364.  
  365. static PyObject *ListObj_LAddToCell(_self, _args)
  366.     ListObject *_self;
  367.     PyObject *_args;
  368. {
  369.     PyObject *_res = NULL;
  370.     char *dataPtr__in__;
  371.     short dataPtr__len__;
  372.     int dataPtr__in_len__;
  373.     Point theCell;
  374.     if (!PyArg_ParseTuple(_args, "s#O&",
  375.                           &dataPtr__in__, &dataPtr__in_len__,
  376.                           PyMac_GetPoint, &theCell))
  377.         return NULL;
  378.     dataPtr__len__ = dataPtr__in_len__;
  379.     LAddToCell(dataPtr__in__, dataPtr__len__,
  380.                theCell,
  381.                _self->ob_itself);
  382.     Py_INCREF(Py_None);
  383.     _res = Py_None;
  384.  dataPtr__error__: ;
  385.     return _res;
  386. }
  387.  
  388. static PyObject *ListObj_LClrCell(_self, _args)
  389.     ListObject *_self;
  390.     PyObject *_args;
  391. {
  392.     PyObject *_res = NULL;
  393.     Point theCell;
  394.     if (!PyArg_ParseTuple(_args, "O&",
  395.                           PyMac_GetPoint, &theCell))
  396.         return NULL;
  397.     LClrCell(theCell,
  398.              _self->ob_itself);
  399.     Py_INCREF(Py_None);
  400.     _res = Py_None;
  401.     return _res;
  402. }
  403.  
  404. static PyObject *ListObj_LGetCell(_self, _args)
  405.     ListObject *_self;
  406.     PyObject *_args;
  407. {
  408.     PyObject *_res = NULL;
  409.     char *dataPtr__out__;
  410.     short dataPtr__len__;
  411.     int dataPtr__in_len__;
  412.     Point theCell;
  413.     if (!PyArg_ParseTuple(_args, "iO&",
  414.                           &dataPtr__in_len__,
  415.                           PyMac_GetPoint, &theCell))
  416.         return NULL;
  417.     if ((dataPtr__out__ = malloc(dataPtr__in_len__)) == NULL)
  418.     {
  419.         PyErr_NoMemory();
  420.         goto dataPtr__error__;
  421.     }
  422.     dataPtr__len__ = dataPtr__in_len__;
  423.     LGetCell(dataPtr__out__, &dataPtr__len__,
  424.              theCell,
  425.              _self->ob_itself);
  426.     _res = Py_BuildValue("s#",
  427.                          dataPtr__out__, (int)dataPtr__len__);
  428.     free(dataPtr__out__);
  429.  dataPtr__error__: ;
  430.     return _res;
  431. }
  432.  
  433. static PyObject *ListObj_LRect(_self, _args)
  434.     ListObject *_self;
  435.     PyObject *_args;
  436. {
  437.     PyObject *_res = NULL;
  438.     Rect cellRect;
  439.     Point theCell;
  440.     if (!PyArg_ParseTuple(_args, "O&",
  441.                           PyMac_GetPoint, &theCell))
  442.         return NULL;
  443.     LRect(&cellRect,
  444.           theCell,
  445.           _self->ob_itself);
  446.     _res = Py_BuildValue("O&",
  447.                          PyMac_BuildRect, &cellRect);
  448.     return _res;
  449. }
  450.  
  451. static PyObject *ListObj_LSetCell(_self, _args)
  452.     ListObject *_self;
  453.     PyObject *_args;
  454. {
  455.     PyObject *_res = NULL;
  456.     char *dataPtr__in__;
  457.     short dataPtr__len__;
  458.     int dataPtr__in_len__;
  459.     Point theCell;
  460.     if (!PyArg_ParseTuple(_args, "s#O&",
  461.                           &dataPtr__in__, &dataPtr__in_len__,
  462.                           PyMac_GetPoint, &theCell))
  463.         return NULL;
  464.     dataPtr__len__ = dataPtr__in_len__;
  465.     LSetCell(dataPtr__in__, dataPtr__len__,
  466.              theCell,
  467.              _self->ob_itself);
  468.     Py_INCREF(Py_None);
  469.     _res = Py_None;
  470.  dataPtr__error__: ;
  471.     return _res;
  472. }
  473.  
  474. static PyObject *ListObj_LSetSelect(_self, _args)
  475.     ListObject *_self;
  476.     PyObject *_args;
  477. {
  478.     PyObject *_res = NULL;
  479.     Boolean setIt;
  480.     Point theCell;
  481.     if (!PyArg_ParseTuple(_args, "bO&",
  482.                           &setIt,
  483.                           PyMac_GetPoint, &theCell))
  484.         return NULL;
  485.     LSetSelect(setIt,
  486.                theCell,
  487.                _self->ob_itself);
  488.     Py_INCREF(Py_None);
  489.     _res = Py_None;
  490.     return _res;
  491. }
  492.  
  493. static PyObject *ListObj_LDraw(_self, _args)
  494.     ListObject *_self;
  495.     PyObject *_args;
  496. {
  497.     PyObject *_res = NULL;
  498.     Point theCell;
  499.     if (!PyArg_ParseTuple(_args, "O&",
  500.                           PyMac_GetPoint, &theCell))
  501.         return NULL;
  502.     LDraw(theCell,
  503.           _self->ob_itself);
  504.     Py_INCREF(Py_None);
  505.     _res = Py_None;
  506.     return _res;
  507. }
  508.  
  509. static PyMethodDef ListObj_methods[] = {
  510.     {"LAddColumn", (PyCFunction)ListObj_LAddColumn, 1,
  511.      "(short count, short colNum) -> (short _rv)"},
  512.     {"LAddRow", (PyCFunction)ListObj_LAddRow, 1,
  513.      "(short count, short rowNum) -> (short _rv)"},
  514.     {"LDelColumn", (PyCFunction)ListObj_LDelColumn, 1,
  515.      "(short count, short colNum) -> None"},
  516.     {"LDelRow", (PyCFunction)ListObj_LDelRow, 1,
  517.      "(short count, short rowNum) -> None"},
  518.     {"LGetSelect", (PyCFunction)ListObj_LGetSelect, 1,
  519.      "(Boolean next, Point theCell) -> (Boolean _rv, Point theCell)"},
  520.     {"LLastClick", (PyCFunction)ListObj_LLastClick, 1,
  521.      "() -> (Point _rv)"},
  522.     {"LNextCell", (PyCFunction)ListObj_LNextCell, 1,
  523.      "(Boolean hNext, Boolean vNext, Point theCell) -> (Boolean _rv, Point theCell)"},
  524.     {"LSize", (PyCFunction)ListObj_LSize, 1,
  525.      "(short listWidth, short listHeight) -> None"},
  526.     {"LSetDrawingMode", (PyCFunction)ListObj_LSetDrawingMode, 1,
  527.      "(Boolean drawIt) -> None"},
  528.     {"LScroll", (PyCFunction)ListObj_LScroll, 1,
  529.      "(short dCols, short dRows) -> None"},
  530.     {"LAutoScroll", (PyCFunction)ListObj_LAutoScroll, 1,
  531.      "() -> None"},
  532.     {"LUpdate", (PyCFunction)ListObj_LUpdate, 1,
  533.      "(RgnHandle theRgn) -> None"},
  534.     {"LActivate", (PyCFunction)ListObj_LActivate, 1,
  535.      "(Boolean act) -> None"},
  536.     {"LCellSize", (PyCFunction)ListObj_LCellSize, 1,
  537.      "(Point cSize) -> None"},
  538.     {"LClick", (PyCFunction)ListObj_LClick, 1,
  539.      "(Point pt, short modifiers) -> (Boolean _rv)"},
  540.     {"LAddToCell", (PyCFunction)ListObj_LAddToCell, 1,
  541.      "(Buffer dataPtr, Point theCell) -> None"},
  542.     {"LClrCell", (PyCFunction)ListObj_LClrCell, 1,
  543.      "(Point theCell) -> None"},
  544.     {"LGetCell", (PyCFunction)ListObj_LGetCell, 1,
  545.      "(Buffer dataPtr, Point theCell) -> (Buffer dataPtr)"},
  546.     {"LRect", (PyCFunction)ListObj_LRect, 1,
  547.      "(Point theCell) -> (Rect cellRect)"},
  548.     {"LSetCell", (PyCFunction)ListObj_LSetCell, 1,
  549.      "(Buffer dataPtr, Point theCell) -> None"},
  550.     {"LSetSelect", (PyCFunction)ListObj_LSetSelect, 1,
  551.      "(Boolean setIt, Point theCell) -> None"},
  552.     {"LDraw", (PyCFunction)ListObj_LDraw, 1,
  553.      "(Point theCell) -> None"},
  554.     {NULL, NULL, 0}
  555. };
  556.  
  557. PyMethodChain ListObj_chain = { ListObj_methods, NULL };
  558.  
  559. static PyObject *ListObj_getattr(self, name)
  560.     ListObject *self;
  561.     char *name;
  562. {
  563.     {
  564.         /* XXXX Should we HLock() here?? */
  565.         if ( strcmp(name, "listFlags") == 0 )
  566.             return Py_BuildValue("l", (long)(*self->ob_itself)->listFlags & 0xff);
  567.         if ( strcmp(name, "selFlags") == 0 )
  568.             return Py_BuildValue("l", (long)(*self->ob_itself)->selFlags & 0xff);
  569.     }
  570.     return Py_FindMethodInChain(&ListObj_chain, (PyObject *)self, name);
  571. }
  572.  
  573. static int
  574. ListObj_setattr(self, name, value)
  575.     ListObject *self;
  576.     char *name;
  577.     PyObject *value;
  578. {
  579.     long intval;
  580.         
  581.     if ( value == NULL || !PyInt_Check(value) )
  582.         return -1;
  583.     intval = PyInt_AsLong(value);
  584.     if (strcmp(name, "listFlags") == 0 ) {
  585.         /* XXXX Should we HLock the handle here?? */
  586.         (*self->ob_itself)->listFlags = intval;
  587.         return 0;
  588.     }
  589.     if (strcmp(name, "selFlags") == 0 ) {
  590.         (*self->ob_itself)->selFlags = intval;
  591.         return 0;
  592.     }
  593.     return -1;
  594. }
  595.  
  596.  
  597. PyTypeObject List_Type = {
  598.     PyObject_HEAD_INIT(&PyType_Type)
  599.     0, /*ob_size*/
  600.     "List", /*tp_name*/
  601.     sizeof(ListObject), /*tp_basicsize*/
  602.     0, /*tp_itemsize*/
  603.     /* methods */
  604.     (destructor) ListObj_dealloc, /*tp_dealloc*/
  605.     0, /*tp_print*/
  606.     (getattrfunc) ListObj_getattr, /*tp_getattr*/
  607.     (setattrfunc) ListObj_setattr, /*tp_setattr*/
  608. };
  609.  
  610. /* ---------------------- End object type List ---------------------- */
  611.  
  612.  
  613. static PyObject *List_LNew(_self, _args)
  614.     PyObject *_self;
  615.     PyObject *_args;
  616. {
  617.     PyObject *_res = NULL;
  618.     ListRef _rv;
  619.     Rect rView;
  620.     Rect dataBounds;
  621.     Point cSize;
  622.     short theProc;
  623.     WindowPtr theWindow;
  624.     Boolean drawIt;
  625.     Boolean hasGrow;
  626.     Boolean scrollHoriz;
  627.     Boolean scrollVert;
  628.     if (!PyArg_ParseTuple(_args, "O&O&O&hO&bbbb",
  629.                           PyMac_GetRect, &rView,
  630.                           PyMac_GetRect, &dataBounds,
  631.                           PyMac_GetPoint, &cSize,
  632.                           &theProc,
  633.                           WinObj_Convert, &theWindow,
  634.                           &drawIt,
  635.                           &hasGrow,
  636.                           &scrollHoriz,
  637.                           &scrollVert))
  638.         return NULL;
  639.     _rv = LNew(&rView,
  640.                &dataBounds,
  641.                cSize,
  642.                theProc,
  643.                theWindow,
  644.                drawIt,
  645.                hasGrow,
  646.                scrollHoriz,
  647.                scrollVert);
  648.     _res = Py_BuildValue("O&",
  649.                          ListObj_New, _rv);
  650.     return _res;
  651. }
  652.  
  653. static PyMethodDef List_methods[] = {
  654.     {"LNew", (PyCFunction)List_LNew, 1,
  655.      "(Rect rView, Rect dataBounds, Point cSize, short theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListRef _rv)"},
  656.     {NULL, NULL, 0}
  657. };
  658.  
  659.  
  660.  
  661.  
  662. void initList()
  663. {
  664.     PyObject *m;
  665.     PyObject *d;
  666.  
  667.  
  668.  
  669.  
  670.     m = Py_InitModule("List", List_methods);
  671.     d = PyModule_GetDict(m);
  672.     List_Error = PyMac_GetOSErrException();
  673.     if (List_Error == NULL ||
  674.         PyDict_SetItemString(d, "Error", List_Error) != 0)
  675.         Py_FatalError("can't initialize List.Error");
  676. }
  677.  
  678. /* ======================== End module List ========================= */
  679.  
  680.