Interface to the Mac List Manager.

Mac/Lib/test/tlist.py

+# Test List module.
+# Draw a window with all the files in the current folder.
+# double-clicking will change folder.
+#
+# This test expects Win, Evt and FrameWork (and anything used by those)
+# to work.
+
+from FrameWork import *
+import Win
+import Qd
+import List
+import os
+
+class TestList(Application):
+	def __init__(self):
+		os.chdir('Moes:')
+		self.makemenubar()
+		self.makewindow()
+	
+	def makewindow(self):
+		r = (40, 40, 400, 300)
+		w = Win.NewWindow(r, "List test", 1, 0, -1, 1, 0x55555555)
+		r2 = (0, 0, 345, 245)
+		self.list = List.LNew(r2, (0, 0, 1, 1), (0,0), 0, w, 0, 1, 1, 1)
+		self.filllist()
+		w.DrawGrowIcon()
+		self.win = w
+		
+	def makeusermenus(self):
+		self.filemenu = m = Menu(self.menubar, "File")
+		self.quititem = MenuItem(m, "Quit", "Q", self.quit)
+	
+	def quit(self, *args):
+		raise self
+
+	def do_about(self, id, item, window, event):
+		EasyDialogs.Message("""Test the List Manager interface.
+		Double-click on a folder to change directory""")
+		
+	def do_activateEvt(self, *args):
+		self.list.LActivate(1)	# XXXX Wrong...
+		
+	def do_update(self, *args):
+		print 'LUPDATE'
+		self.list.LUpdate()
+
+	def do_inContent(self, partcode, window, event):
+		(what, message, when, where, modifiers) = event
+		Qd.SetPort(window)
+		local = Qd.GlobalToLocal(where)
+		print 'CLICK', where, '->', local
+		dclick = self.list.LClick(local, modifiers)
+		if dclick:
+			h, v = self.list.LLastClick()
+			file = self.list.LGetCell(1000, (h, v))
+			os.chdir(file)
+			self.filllist()
+
+	def filllist(self):
+		"""Fill the list with the contents of the current directory"""
+		l = self.list
+		l.LSetDrawingMode(0)
+		l.LDelRow(0, 0)
+		contents = os.listdir(':')
+		print contents
+		l.LAddRow(len(contents), 0)
+		for i in range(len(contents)):
+			l.LSetCell(contents[i], (0, i))
+		l.LSetDrawingMode(1)
+		l.LUpdate()
+
+
+def main():
+	App = TestList()
+	App.mainloop()
+	
+if __name__ == '__main__':
+	main()
+	

Mac/Lib/toolbox/Lists.py

+# Generated from 'Sap:CodeWarrior6:Metrowerks C/C++:Headers:Universal Headers 2.0.1f:Lists.h'
+
+lDoVAutoscroll = 2
+lDoHAutoscroll = 1
+lOnlyOne = -128
+lExtendDrag = 64
+lNoDisjoint = 32
+lNoExtend = 16
+lNoRect = 8
+lUseSense = 4
+lNoNilHilite = 2
+lInitMsg = 0
+lDrawMsg = 1
+lHiliteMsg = 2
+lCloseMsg = 3

Mac/Modules/list/Listmodule.c

+
+/* ========================== Module List =========================== */
+
+#include "Python.h"
+
+
+
+#define SystemSevenOrLater 1
+
+#include "macglue.h"
+#include <Memory.h>
+#include <Dialogs.h>
+#include <Menus.h>
+#include <Controls.h>
+
+extern PyObject *ResObj_New(Handle);
+extern int ResObj_Convert(PyObject *, Handle *);
+
+extern PyObject *WinObj_New(WindowPtr);
+extern int WinObj_Convert(PyObject *, WindowPtr *);
+
+extern PyObject *DlgObj_New(DialogPtr);
+extern int DlgObj_Convert(PyObject *, DialogPtr *);
+extern PyTypeObject Dialog_Type;
+#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
+
+extern PyObject *MenuObj_New(MenuHandle);
+extern int MenuObj_Convert(PyObject *, MenuHandle *);
+
+extern PyObject *CtlObj_New(ControlHandle);
+extern int CtlObj_Convert(PyObject *, ControlHandle *);
+
+extern PyObject *WinObj_WhichWindow(WindowPtr);
+
+#include <Lists.h>
+
+static PyObject *List_Error;
+
+/* ------------------------ Object type List ------------------------ */
+
+PyTypeObject List_Type;
+
+#define ListObj_Check(x) ((x)->ob_type == &List_Type)
+
+typedef struct ListObject {
+	PyObject_HEAD
+	ListRef ob_itself;
+} ListObject;
+
+PyObject *ListObj_New(itself)
+	ListRef itself;
+{
+	ListObject *it;
+	if (itself == NULL) {
+						PyErr_SetString(List_Error,"Cannot create null List");
+						return NULL;
+					}
+	it = PyObject_NEW(ListObject, &List_Type);
+	if (it == NULL) return NULL;
+	it->ob_itself = itself;
+	return (PyObject *)it;
+}
+ListObj_Convert(v, p_itself)
+	PyObject *v;
+	ListRef *p_itself;
+{
+	if (!ListObj_Check(v))
+	{
+		PyErr_SetString(PyExc_TypeError, "List required");
+		return 0;
+	}
+	*p_itself = ((ListObject *)v)->ob_itself;
+	return 1;
+}
+
+static void ListObj_dealloc(self)
+	ListObject *self;
+{
+	LDispose(self->ob_itself);
+	PyMem_DEL(self);
+}
+
+static PyObject *ListObj_LAddColumn(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	short count;
+	short colNum;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &count,
+	                      &colNum))
+		return NULL;
+	_rv = LAddColumn(count,
+	                 colNum,
+	                 _self->ob_itself);
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *ListObj_LAddRow(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	short count;
+	short rowNum;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &count,
+	                      &rowNum))
+		return NULL;
+	_rv = LAddRow(count,
+	              rowNum,
+	              _self->ob_itself);
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *ListObj_LDelColumn(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short count;
+	short colNum;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &count,
+	                      &colNum))
+		return NULL;
+	LDelColumn(count,
+	           colNum,
+	           _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *ListObj_LDelRow(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short count;
+	short rowNum;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &count,
+	                      &rowNum))
+		return NULL;
+	LDelRow(count,
+	        rowNum,
+	        _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *ListObj_LGetSelect(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	Boolean next;
+	Point theCell;
+	if (!PyArg_ParseTuple(_args, "bO&",
+	                      &next,
+	                      PyMac_GetPoint, &theCell))
+		return NULL;
+	_rv = LGetSelect(next,
+	                 &theCell,
+	                 _self->ob_itself);
+	_res = Py_BuildValue("bO&",
+	                     _rv,
+	                     PyMac_BuildPoint, theCell);
+	return _res;
+}
+
+static PyObject *ListObj_LLastClick(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Point _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = LLastClick(_self->ob_itself);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildPoint, _rv);
+	return _res;
+}
+
+static PyObject *ListObj_LNextCell(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	Boolean hNext;
+	Boolean vNext;
+	Point theCell;
+	if (!PyArg_ParseTuple(_args, "bbO&",
+	                      &hNext,
+	                      &vNext,
+	                      PyMac_GetPoint, &theCell))
+		return NULL;
+	_rv = LNextCell(hNext,
+	                vNext,
+	                &theCell,
+	                _self->ob_itself);
+	_res = Py_BuildValue("bO&",
+	                     _rv,
+	                     PyMac_BuildPoint, theCell);
+	return _res;
+}
+
+static PyObject *ListObj_LSize(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short listWidth;
+	short listHeight;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &listWidth,
+	                      &listHeight))
+		return NULL;
+	LSize(listWidth,
+	      listHeight,
+	      _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *ListObj_LSetDrawingMode(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean drawIt;
+	if (!PyArg_ParseTuple(_args, "b",
+	                      &drawIt))
+		return NULL;
+	LSetDrawingMode(drawIt,
+	                _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *ListObj_LScroll(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short dCols;
+	short dRows;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &dCols,
+	                      &dRows))
+		return NULL;
+	LScroll(dCols,
+	        dRows,
+	        _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *ListObj_LAutoScroll(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	LAutoScroll(_self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *ListObj_LUpdate(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	LUpdate((*_self->ob_itself)->port->visRgn,
+	        _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *ListObj_LActivate(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean act;
+	if (!PyArg_ParseTuple(_args, "b",
+	                      &act))
+		return NULL;
+	LActivate(act,
+	          _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *ListObj_LCellSize(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Point cSize;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetPoint, &cSize))
+		return NULL;
+	LCellSize(cSize,
+	          _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *ListObj_LClick(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	Point pt;
+	short modifiers;
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      PyMac_GetPoint, &pt,
+	                      &modifiers))
+		return NULL;
+	_rv = LClick(pt,
+	             modifiers,
+	             _self->ob_itself);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *ListObj_LAddToCell(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	char *dataPtr__in__;
+	short dataPtr__len__;
+	int dataPtr__in_len__;
+	Point theCell;
+	if (!PyArg_ParseTuple(_args, "s#O&",
+	                      &dataPtr__in__, &dataPtr__in_len__,
+	                      PyMac_GetPoint, &theCell))
+		return NULL;
+	dataPtr__len__ = dataPtr__in_len__;
+	LAddToCell(dataPtr__in__, dataPtr__len__,
+	           theCell,
+	           _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+ dataPtr__error__: ;
+	return _res;
+}
+
+static PyObject *ListObj_LClrCell(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Point theCell;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetPoint, &theCell))
+		return NULL;
+	LClrCell(theCell,
+	         _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *ListObj_LGetCell(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	char *dataPtr__out__;
+	short dataPtr__len__;
+	int dataPtr__in_len__;
+	Point theCell;
+	if (!PyArg_ParseTuple(_args, "iO&",
+	                      &dataPtr__in_len__,
+	                      PyMac_GetPoint, &theCell))
+		return NULL;
+	if ((dataPtr__out__ = malloc(dataPtr__in_len__)) == NULL)
+	{
+		PyErr_NoMemory();
+		goto dataPtr__error__;
+	}
+	dataPtr__len__ = dataPtr__in_len__;
+	LGetCell(dataPtr__out__, &dataPtr__len__,
+	         theCell,
+	         _self->ob_itself);
+	_res = Py_BuildValue("s#",
+	                     dataPtr__out__, (int)dataPtr__len__);
+	free(dataPtr__out__);
+ dataPtr__error__: ;
+	return _res;
+}
+
+static PyObject *ListObj_LRect(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect cellRect;
+	Point theCell;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetPoint, &theCell))
+		return NULL;
+	LRect(&cellRect,
+	      theCell,
+	      _self->ob_itself);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildRect, &cellRect);
+	return _res;
+}
+
+static PyObject *ListObj_LSetCell(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	char *dataPtr__in__;
+	short dataPtr__len__;
+	int dataPtr__in_len__;
+	Point theCell;
+	if (!PyArg_ParseTuple(_args, "s#O&",
+	                      &dataPtr__in__, &dataPtr__in_len__,
+	                      PyMac_GetPoint, &theCell))
+		return NULL;
+	dataPtr__len__ = dataPtr__in_len__;
+	LSetCell(dataPtr__in__, dataPtr__len__,
+	         theCell,
+	         _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+ dataPtr__error__: ;
+	return _res;
+}
+
+static PyObject *ListObj_LSetSelect(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean setIt;
+	Point theCell;
+	if (!PyArg_ParseTuple(_args, "bO&",
+	                      &setIt,
+	                      PyMac_GetPoint, &theCell))
+		return NULL;
+	LSetSelect(setIt,
+	           theCell,
+	           _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *ListObj_LDraw(_self, _args)
+	ListObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Point theCell;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetPoint, &theCell))
+		return NULL;
+	LDraw(theCell,
+	      _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyMethodDef ListObj_methods[] = {
+	{"LAddColumn", (PyCFunction)ListObj_LAddColumn, 1,
+	 "(short count, short colNum) -> (short _rv)"},
+	{"LAddRow", (PyCFunction)ListObj_LAddRow, 1,
+	 "(short count, short rowNum) -> (short _rv)"},
+	{"LDelColumn", (PyCFunction)ListObj_LDelColumn, 1,
+	 "(short count, short colNum) -> None"},
+	{"LDelRow", (PyCFunction)ListObj_LDelRow, 1,
+	 "(short count, short rowNum) -> None"},
+	{"LGetSelect", (PyCFunction)ListObj_LGetSelect, 1,
+	 "(Boolean next, Point theCell) -> (Boolean _rv, Point theCell)"},
+	{"LLastClick", (PyCFunction)ListObj_LLastClick, 1,
+	 "() -> (Point _rv)"},
+	{"LNextCell", (PyCFunction)ListObj_LNextCell, 1,
+	 "(Boolean hNext, Boolean vNext, Point theCell) -> (Boolean _rv, Point theCell)"},
+	{"LSize", (PyCFunction)ListObj_LSize, 1,
+	 "(short listWidth, short listHeight) -> None"},
+	{"LSetDrawingMode", (PyCFunction)ListObj_LSetDrawingMode, 1,
+	 "(Boolean drawIt) -> None"},
+	{"LScroll", (PyCFunction)ListObj_LScroll, 1,
+	 "(short dCols, short dRows) -> None"},
+	{"LAutoScroll", (PyCFunction)ListObj_LAutoScroll, 1,
+	 "() -> None"},
+	{"LUpdate", (PyCFunction)ListObj_LUpdate, 1,
+	 "() -> None"},
+	{"LActivate", (PyCFunction)ListObj_LActivate, 1,
+	 "(Boolean act) -> None"},
+	{"LCellSize", (PyCFunction)ListObj_LCellSize, 1,
+	 "(Point cSize) -> None"},
+	{"LClick", (PyCFunction)ListObj_LClick, 1,
+	 "(Point pt, short modifiers) -> (Boolean _rv)"},
+	{"LAddToCell", (PyCFunction)ListObj_LAddToCell, 1,
+	 "(Buffer dataPtr, Point theCell) -> None"},
+	{"LClrCell", (PyCFunction)ListObj_LClrCell, 1,
+	 "(Point theCell) -> None"},
+	{"LGetCell", (PyCFunction)ListObj_LGetCell, 1,
+	 "(Buffer dataPtr, Point theCell) -> (Buffer dataPtr)"},
+	{"LRect", (PyCFunction)ListObj_LRect, 1,
+	 "(Point theCell) -> (Rect cellRect)"},
+	{"LSetCell", (PyCFunction)ListObj_LSetCell, 1,
+	 "(Buffer dataPtr, Point theCell) -> None"},
+	{"LSetSelect", (PyCFunction)ListObj_LSetSelect, 1,
+	 "(Boolean setIt, Point theCell) -> None"},
+	{"LDraw", (PyCFunction)ListObj_LDraw, 1,
+	 "(Point theCell) -> None"},
+	{NULL, NULL, 0}
+};
+
+PyMethodChain ListObj_chain = { ListObj_methods, NULL };
+
+static PyObject *ListObj_getattr(self, name)
+	ListObject *self;
+	char *name;
+{
+	return Py_FindMethodInChain(&ListObj_chain, (PyObject *)self, name);
+}
+
+#define ListObj_setattr NULL
+
+PyTypeObject List_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0, /*ob_size*/
+	"List", /*tp_name*/
+	sizeof(ListObject), /*tp_basicsize*/
+	0, /*tp_itemsize*/
+	/* methods */
+	(destructor) ListObj_dealloc, /*tp_dealloc*/
+	0, /*tp_print*/
+	(getattrfunc) ListObj_getattr, /*tp_getattr*/
+	(setattrfunc) ListObj_setattr, /*tp_setattr*/
+};
+
+/* ---------------------- End object type List ---------------------- */
+
+
+static PyObject *List_LNew(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	ListRef _rv;
+	Rect rView;
+	Rect dataBounds;
+	Point cSize;
+	short theProc;
+	WindowPtr theWindow;
+	Boolean drawIt;
+	Boolean hasGrow;
+	Boolean scrollHoriz;
+	Boolean scrollVert;
+	if (!PyArg_ParseTuple(_args, "O&O&O&hO&bbbb",
+	                      PyMac_GetRect, &rView,
+	                      PyMac_GetRect, &dataBounds,
+	                      PyMac_GetPoint, &cSize,
+	                      &theProc,
+	                      WinObj_Convert, &theWindow,
+	                      &drawIt,
+	                      &hasGrow,
+	                      &scrollHoriz,
+	                      &scrollVert))
+		return NULL;
+	_rv = LNew(&rView,
+	           &dataBounds,
+	           cSize,
+	           theProc,
+	           theWindow,
+	           drawIt,
+	           hasGrow,
+	           scrollHoriz,
+	           scrollVert);
+	_res = Py_BuildValue("O&",
+	                     ListObj_New, _rv);
+	return _res;
+}
+
+static PyMethodDef List_methods[] = {
+	{"LNew", (PyCFunction)List_LNew, 1,
+	 "(Rect rView, Rect dataBounds, Point cSize, short theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListRef _rv)"},
+	{NULL, NULL, 0}
+};
+
+
+
+
+void initList()
+{
+	PyObject *m;
+	PyObject *d;
+
+
+
+
+	m = Py_InitModule("List", List_methods);
+	d = PyModule_GetDict(m);
+	List_Error = PyMac_GetOSErrException();
+	if (List_Error == NULL ||
+	    PyDict_SetItemString(d, "Error", List_Error) != 0)
+		Py_FatalError("can't initialize List.Error");
+}
+
+/* ======================== End module List ========================= */
+

Mac/Modules/list/listgen.py

+# Generated from 'Sap:CodeWarrior6:Metrowerks C/C++:Headers:Universal Headers 2.0.1f:Lists.h'
+
+f = Function(ListRef, 'LNew',
+    (Rect_ptr, 'rView', InMode),
+    (Rect_ptr, 'dataBounds', InMode),
+    (Point, 'cSize', InMode),
+    (short, 'theProc', InMode),
+    (WindowRef, 'theWindow', InMode),
+    (Boolean, 'drawIt', InMode),
+    (Boolean, 'hasGrow', InMode),
+    (Boolean, 'scrollHoriz', InMode),
+    (Boolean, 'scrollVert', InMode),
+)
+functions.append(f)
+
+f = Method(short, 'LAddColumn',
+    (short, 'count', InMode),
+    (short, 'colNum', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(short, 'LAddRow',
+    (short, 'count', InMode),
+    (short, 'rowNum', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LDelColumn',
+    (short, 'count', InMode),
+    (short, 'colNum', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LDelRow',
+    (short, 'count', InMode),
+    (short, 'rowNum', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(Boolean, 'LGetSelect',
+    (Boolean, 'next', InMode),
+    (Cell, 'theCell', InOutMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(Cell, 'LLastClick',
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(Boolean, 'LNextCell',
+    (Boolean, 'hNext', InMode),
+    (Boolean, 'vNext', InMode),
+    (Cell, 'theCell', InOutMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LSize',
+    (short, 'listWidth', InMode),
+    (short, 'listHeight', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LSetDrawingMode',
+    (Boolean, 'drawIt', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LScroll',
+    (short, 'dCols', InMode),
+    (short, 'dRows', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LAutoScroll',
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LUpdate',
+    (RgnHandle, 'theRgn', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LActivate',
+    (Boolean, 'act', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LCellSize',
+    (Point, 'cSize', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(Boolean, 'LClick',
+    (Point, 'pt', InMode),
+    (short, 'modifiers', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LAddToCell',
+    (InBufferShortsize, 'dataPtr', InMode),
+    (Cell, 'theCell', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LClrCell',
+    (Cell, 'theCell', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LGetCell',
+    (VarOutBufferShortsize, 'dataPtr', InOutMode),
+    (Cell, 'theCell', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LRect',
+    (Rect, 'cellRect', OutMode),
+    (Cell, 'theCell', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LSetCell',
+    (InBufferShortsize, 'dataPtr', InMode),
+    (Cell, 'theCell', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LSetSelect',
+    (Boolean, 'setIt', InMode),
+    (Cell, 'theCell', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'LDraw',
+    (Cell, 'theCell', InMode),
+    (ListRef, 'lHandle', InMode),
+)
+methods.append(f)
+

Mac/Modules/list/listscan.py

+# Scan an Apple header file, generating a Python file of generator calls.
+
+import addpack
+addpack.addpack(':tools:bgen:bgen')
+from scantools import Scanner
+
+LONG = "Lists"
+SHORT = "list"
+OBJECT = "ListRef"
+
+def main():
+	input = LONG + ".h"
+	output = SHORT + "gen.py"
+	defsoutput = LONG + ".py"
+	scanner = MyScanner(input, output, defsoutput)
+	scanner.scan()
+	scanner.close()
+	print "=== Done scanning and generating, now importing the generated code... ==="
+	exec "import " + SHORT + "support"
+	print "=== Done.  It's up to you to compile it now! ==="
+
+class MyScanner(Scanner):
+
+	def destination(self, type, name, arglist):
+		classname = "Function"
+		listname = "functions"
+		if arglist:
+			t, n, m = arglist[-1]
+			# This is non-functional today
+			if t == OBJECT and m == "InMode":
+				classname = "Method"
+				listname = "methods"
+		return classname, listname
+
+	def makeblacklistnames(self):
+		return [
+			"LDispose",		# Done by removing the object
+			"LSearch",		# We don't want to handle procs just yet
+			"LGetCellDataLocation",		# What does this do??
+			]
+
+	def makeblacklisttypes(self):
+		return [
+			]
+
+	def makerepairinstructions(self):
+		return [
+			([('ListBounds_ptr', '*', 'InMode')],
+			 [('Rect_ptr', '*', 'InMode')]),
+
+			([("Cell", "theCell", "OutMode")],
+			 [("Cell", "theCell", "InOutMode")]),
+			 
+			([("void_ptr", "*", "InMode"), ("short", "*", "InMode")],
+			 [("InBufferShortsize", "*", "*")]),
+			
+			([("void", "*", "OutMode"), ("short", "*", "OutMode")],
+			 [("VarOutBufferShortsize", "*", "InOutMode")]),
+			
+#			([("void", "wStorage", "OutMode")],
+#			 [("NullStorage", "*", "InMode")]),
+#			
+#			# GetKeys
+#			([('KeyMap', 'theKeys', 'InMode')],
+#			 [('*', '*', 'OutMode')]),
+#			 
+#			# GetTicker
+#			([('unsigned long', '*', '*')],
+#			 [('unsigned_long', '*', '*')]),
+			]
+			
+if __name__ == "__main__":
+	main()

Mac/Modules/list/listsupport.py

+# This script generates a Python interface for an Apple Macintosh Manager.
+# It uses the "bgen" package to generate C code.
+# The function specifications are generated by scanning the mamager's header file,
+# using the "scantools" package (customized for this particular manager).
+
+import string
+
+# Declarations that change for each manager
+MACHEADERFILE = 'Lists.h'		# The Apple header file
+MODNAME = 'List'				# The name of the module
+OBJECTNAME = 'List'			# The basic name of the objects used here
+KIND = 'Handle'				# Usually 'Ptr' or 'Handle'
+
+# The following is *usually* unchanged but may still require tuning
+MODPREFIX = MODNAME			# The prefix for module-wide routines
+OBJECTTYPE = "ListRef"		# The C type used to represent them
+OBJECTPREFIX = MODPREFIX + 'Obj'	# The prefix for object methods
+INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner
+OUTPUTFILE = MODNAME + "module.c"	# The file generated by this program
+
+from macsupport import *
+
+# Create the type objects
+ListRef = OpaqueByValueType("ListRef", "ListObj")
+Cell = Point
+VarOutBufferShortsize = VarHeapOutputBufferType('char', 'short', 's')	# (buf, &len)
+InBufferShortsize = VarInputBufferType('char', 'short', 's')		# (buf, len)
+
+# For LUpdate, we alsways update the complete visible region.
+RgnHandle = FakeType("(*_self->ob_itself)->port->visRgn")
+
+
+includestuff = includestuff + """
+#include <%s>""" % MACHEADERFILE + """
+"""
+
+class ListMethodGenerator(MethodGenerator):
+	"""Similar to MethodGenerator, but has self as last argument"""
+
+	def parseArgumentList(self, args):
+		args, a0 = args[:-1], args[-1]
+		t0, n0, m0 = a0
+		if m0 != InMode:
+			raise ValueError, "method's 'self' must be 'InMode'"
+		self.itself = Variable(t0, "_self->ob_itself", SelfMode)
+		FunctionGenerator.parseArgumentList(self, args)
+		self.argumentList.append(self.itself)
+
+
+
+class MyObjectDefinition(GlobalObjectDefinition):
+	def outputCheckNewArg(self):
+		Output("""if (itself == NULL) {
+					PyErr_SetString(List_Error,"Cannot create null List");
+					return NULL;
+				}""")
+	def outputFreeIt(self, itselfname):
+		Output("LDispose(%s);", itselfname)
+
+# From here on it's basically all boiler plate...
+
+# Create the generator groups and link them
+module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff)
+object = MyObjectDefinition(OBJECTNAME, OBJECTPREFIX, OBJECTTYPE)
+module.addobject(object)
+
+# Create the generator classes used to populate the lists
+Function = FunctionGenerator
+Method = ListMethodGenerator
+
+# Create and populate the lists
+functions = []
+methods = []
+execfile(INPUTFILE)
+
+# add the populated lists to the generator groups
+# (in a different wordl the scan program would generate this)
+for f in functions: module.add(f)
+for f in methods: object.add(f)
+
+# generate output (open the output file as late as possible)
+SetOutputFileName(OUTPUTFILE)
+module.generate()
+