Interface to TextEdit toolbox

3 files changed, 1179 insertions, 0 deletions

diff --git a/Mac/Modules/te/TEmodule.c b/Mac/Modules/te/TEmodule.c
new file mode 100644
index 0000000..5b54822
--- /dev/null
+++ b/Mac/Modules/te/TEmodule.c
@@ -0,0 +1,1005 @@
+
+/* =========================== Module TE ============================ */
+
+#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 *OptResObj_New(Handle);
+extern int OptResObj_Convert(PyObject *, Handle *);
+
+extern PyObject *WinObj_New(WindowPtr);
+extern int WinObj_Convert(PyObject *, WindowPtr *);
+extern PyTypeObject Window_Type;
+#define WinObj_Check(x) ((x)->ob_type == &Window_Type)
+
+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 *GrafObj_New(GrafPtr);
+extern int GrafObj_Convert(PyObject *, GrafPtr *);
+
+extern PyObject *BMObj_New(BitMapPtr);
+extern int BMObj_Convert(PyObject *, BitMapPtr *);
+
+extern PyObject *PMObj_New(PixMapHandle);
+extern int PMObj_Convert(PyObject *, PixMapHandle *);
+
+extern PyObject *WinObj_WhichWindow(WindowPtr);
+
+#include <TextEdit.h>
+
+/* Exported by Qdmodule.c: */
+extern PyObject *QdRGB_New(RGBColor *);
+extern int QdRGB_Convert(PyObject *, RGBColor *);
+
+/*
+** Parse/generate TextStyle records
+*/
+PyObject *TextStyle_New(itself)
+	TextStylePtr itself;
+{
+
+	return Py_BuildValue("lllO&", (long)itself->tsFont, (long)itself->tsFace, (long)itself->tsSize, QdRGB_New,
+				&itself->tsColor);
+}
+
+TextStyle_Convert(v, p_itself)
+	PyObject *v;
+	TextStylePtr p_itself;
+{
+	long font, face, size;
+	
+	if( !PyArg_ParseTuple(v, "lllO&", &font, &face, &size, QdRGB_Convert, &p_itself->tsColor) )
+		return 0;
+	p_itself->tsFont = (short)font;
+	p_itself->tsFace = (Style)face;
+	p_itself->tsSize = (short)size;
+	return 1;
+}
+
+static PyObject *TE_Error;
+
+/* ------------------------- Object type TE ------------------------- */
+
+PyTypeObject TE_Type;
+
+#define TEObj_Check(x) ((x)->ob_type == &TE_Type)
+
+typedef struct TEObject {
+	PyObject_HEAD
+	TEHandle ob_itself;
+} TEObject;
+
+PyObject *TEObj_New(itself)
+	TEHandle itself;
+{
+	TEObject *it;
+	if (itself == NULL) {
+						PyErr_SetString(TE_Error,"Cannot create null TE");
+						return NULL;
+					}
+	it = PyObject_NEW(TEObject, &TE_Type);
+	if (it == NULL) return NULL;
+	it->ob_itself = itself;
+	return (PyObject *)it;
+}
+TEObj_Convert(v, p_itself)
+	PyObject *v;
+	TEHandle *p_itself;
+{
+	if (!TEObj_Check(v))
+	{
+		PyErr_SetString(PyExc_TypeError, "TE required");
+		return 0;
+	}
+	*p_itself = ((TEObject *)v)->ob_itself;
+	return 1;
+}
+
+static void TEObj_dealloc(self)
+	TEObject *self;
+{
+	TEDispose(self->ob_itself);
+	PyMem_DEL(self);
+}
+
+static PyObject *TEObj_TESetText(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	char *text__in__;
+	long text__len__;
+	int text__in_len__;
+	if (!PyArg_ParseTuple(_args, "s#",
+	                      &text__in__, &text__in_len__))
+		return NULL;
+	text__len__ = text__in_len__;
+	TESetText(text__in__, text__len__,
+	          _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+ text__error__: ;
+	return _res;
+}
+
+static PyObject *TEObj_TEGetText(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	CharsHandle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = TEGetText(_self->ob_itself);
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *TEObj_TEIdle(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	TEIdle(_self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TESetSelect(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long selStart;
+	long selEnd;
+	if (!PyArg_ParseTuple(_args, "ll",
+	                      &selStart,
+	                      &selEnd))
+		return NULL;
+	TESetSelect(selStart,
+	            selEnd,
+	            _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TEActivate(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	TEActivate(_self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TEDeactivate(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	TEDeactivate(_self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TEKey(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short key;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &key))
+		return NULL;
+	TEKey(key,
+	      _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TECut(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	TECut(_self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TECopy(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	TECopy(_self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TEPaste(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	TEPaste(_self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TEDelete(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	TEDelete(_self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TEInsert(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	char *text__in__;
+	long text__len__;
+	int text__in_len__;
+	if (!PyArg_ParseTuple(_args, "s#",
+	                      &text__in__, &text__in_len__))
+		return NULL;
+	text__len__ = text__in_len__;
+	TEInsert(text__in__, text__len__,
+	         _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+ text__error__: ;
+	return _res;
+}
+
+static PyObject *TEObj_TESetAlignment(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short just;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &just))
+		return NULL;
+	TESetAlignment(just,
+	               _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TEUpdate(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect rUpdate;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetRect, &rUpdate))
+		return NULL;
+	TEUpdate(&rUpdate,
+	         _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TEScroll(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short dh;
+	short dv;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &dh,
+	                      &dv))
+		return NULL;
+	TEScroll(dh,
+	         dv,
+	         _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TESelView(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	TESelView(_self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TEPinScroll(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short dh;
+	short dv;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &dh,
+	                      &dv))
+		return NULL;
+	TEPinScroll(dh,
+	            dv,
+	            _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TEAutoView(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean fAuto;
+	if (!PyArg_ParseTuple(_args, "b",
+	                      &fAuto))
+		return NULL;
+	TEAutoView(fAuto,
+	           _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TECalText(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	TECalText(_self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TEGetOffset(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	Point pt;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetPoint, &pt))
+		return NULL;
+	_rv = TEGetOffset(pt,
+	                  _self->ob_itself);
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *TEObj_TEGetPoint(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Point _rv;
+	short offset;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &offset))
+		return NULL;
+	_rv = TEGetPoint(offset,
+	                 _self->ob_itself);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildPoint, _rv);
+	return _res;
+}
+
+static PyObject *TEObj_TEClick(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Point pt;
+	Boolean fExtend;
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      PyMac_GetPoint, &pt,
+	                      &fExtend))
+		return NULL;
+	TEClick(pt,
+	        fExtend,
+	        _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TESetStyleHandle(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	TEStyleHandle theHandle;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &theHandle))
+		return NULL;
+	TESetStyleHandle(theHandle,
+	                 _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TEGetStyleHandle(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	TEStyleHandle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = TEGetStyleHandle(_self->ob_itself);
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *TEObj_TEGetStyle(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short offset;
+	TextStyle theStyle;
+	short lineHeight;
+	short fontAscent;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &offset))
+		return NULL;
+	TEGetStyle(offset,
+	           &theStyle,
+	           &lineHeight,
+	           &fontAscent,
+	           _self->ob_itself);
+	_res = Py_BuildValue("O&hh",
+	                     TextStyle_New, &theStyle,
+	                     lineHeight,
+	                     fontAscent);
+	return _res;
+}
+
+static PyObject *TEObj_TEStylePaste(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	TEStylePaste(_self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TESetStyle(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short mode;
+	TextStyle newStyle;
+	Boolean fRedraw;
+	if (!PyArg_ParseTuple(_args, "hO&b",
+	                      &mode,
+	                      TextStyle_Convert, &newStyle,
+	                      &fRedraw))
+		return NULL;
+	TESetStyle(mode,
+	           &newStyle,
+	           fRedraw,
+	           _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TEReplaceStyle(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short mode;
+	TextStyle oldStyle;
+	TextStyle newStyle;
+	Boolean fRedraw;
+	if (!PyArg_ParseTuple(_args, "hO&O&b",
+	                      &mode,
+	                      TextStyle_Convert, &oldStyle,
+	                      TextStyle_Convert, &newStyle,
+	                      &fRedraw))
+		return NULL;
+	TEReplaceStyle(mode,
+	               &oldStyle,
+	               &newStyle,
+	               fRedraw,
+	               _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TEGetStyleScrapHandle(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	StScrpHandle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = TEGetStyleScrapHandle(_self->ob_itself);
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *TEObj_TEStyleInsert(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	char *text__in__;
+	long text__len__;
+	int text__in_len__;
+	StScrpHandle hST;
+	if (!PyArg_ParseTuple(_args, "s#O&",
+	                      &text__in__, &text__in_len__,
+	                      ResObj_Convert, &hST))
+		return NULL;
+	text__len__ = text__in_len__;
+	TEStyleInsert(text__in__, text__len__,
+	              hST,
+	              _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+ text__error__: ;
+	return _res;
+}
+
+static PyObject *TEObj_TEGetHeight(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long _rv;
+	long endLine;
+	long startLine;
+	if (!PyArg_ParseTuple(_args, "ll",
+	                      &endLine,
+	                      &startLine))
+		return NULL;
+	_rv = TEGetHeight(endLine,
+	                  startLine,
+	                  _self->ob_itself);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *TEObj_TEContinuousStyle(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	short mode;
+	TextStyle aStyle;
+	if (!PyArg_ParseTuple(_args, "hO&",
+	                      &mode,
+	                      TextStyle_Convert, &aStyle))
+		return NULL;
+	_rv = TEContinuousStyle(&mode,
+	                        &aStyle,
+	                        _self->ob_itself);
+	_res = Py_BuildValue("bhO&",
+	                     _rv,
+	                     mode,
+	                     TextStyle_New, &aStyle);
+	return _res;
+}
+
+static PyObject *TEObj_TEUseStyleScrap(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long rangeStart;
+	long rangeEnd;
+	StScrpHandle newStyles;
+	Boolean fRedraw;
+	if (!PyArg_ParseTuple(_args, "llO&b",
+	                      &rangeStart,
+	                      &rangeEnd,
+	                      ResObj_Convert, &newStyles,
+	                      &fRedraw))
+		return NULL;
+	TEUseStyleScrap(rangeStart,
+	                rangeEnd,
+	                newStyles,
+	                fRedraw,
+	                _self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TEObj_TENumStyles(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long _rv;
+	long rangeStart;
+	long rangeEnd;
+	if (!PyArg_ParseTuple(_args, "ll",
+	                      &rangeStart,
+	                      &rangeEnd))
+		return NULL;
+	_rv = TENumStyles(rangeStart,
+	                  rangeEnd,
+	                  _self->ob_itself);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *TEObj_TEFeatureFlag(_self, _args)
+	TEObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	short feature;
+	short action;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &feature,
+	                      &action))
+		return NULL;
+	_rv = TEFeatureFlag(feature,
+	                    action,
+	                    _self->ob_itself);
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyMethodDef TEObj_methods[] = {
+	{"TESetText", (PyCFunction)TEObj_TESetText, 1,
+	 "(Buffer text) -> None"},
+	{"TEGetText", (PyCFunction)TEObj_TEGetText, 1,
+	 "() -> (CharsHandle _rv)"},
+	{"TEIdle", (PyCFunction)TEObj_TEIdle, 1,
+	 "() -> None"},
+	{"TESetSelect", (PyCFunction)TEObj_TESetSelect, 1,
+	 "(long selStart, long selEnd) -> None"},
+	{"TEActivate", (PyCFunction)TEObj_TEActivate, 1,
+	 "() -> None"},
+	{"TEDeactivate", (PyCFunction)TEObj_TEDeactivate, 1,
+	 "() -> None"},
+	{"TEKey", (PyCFunction)TEObj_TEKey, 1,
+	 "(short key) -> None"},
+	{"TECut", (PyCFunction)TEObj_TECut, 1,
+	 "() -> None"},
+	{"TECopy", (PyCFunction)TEObj_TECopy, 1,
+	 "() -> None"},
+	{"TEPaste", (PyCFunction)TEObj_TEPaste, 1,
+	 "() -> None"},
+	{"TEDelete", (PyCFunction)TEObj_TEDelete, 1,
+	 "() -> None"},
+	{"TEInsert", (PyCFunction)TEObj_TEInsert, 1,
+	 "(Buffer text) -> None"},
+	{"TESetAlignment", (PyCFunction)TEObj_TESetAlignment, 1,
+	 "(short just) -> None"},
+	{"TEUpdate", (PyCFunction)TEObj_TEUpdate, 1,
+	 "(Rect rUpdate) -> None"},
+	{"TEScroll", (PyCFunction)TEObj_TEScroll, 1,
+	 "(short dh, short dv) -> None"},
+	{"TESelView", (PyCFunction)TEObj_TESelView, 1,
+	 "() -> None"},
+	{"TEPinScroll", (PyCFunction)TEObj_TEPinScroll, 1,
+	 "(short dh, short dv) -> None"},
+	{"TEAutoView", (PyCFunction)TEObj_TEAutoView, 1,
+	 "(Boolean fAuto) -> None"},
+	{"TECalText", (PyCFunction)TEObj_TECalText, 1,
+	 "() -> None"},
+	{"TEGetOffset", (PyCFunction)TEObj_TEGetOffset, 1,
+	 "(Point pt) -> (short _rv)"},
+	{"TEGetPoint", (PyCFunction)TEObj_TEGetPoint, 1,
+	 "(short offset) -> (Point _rv)"},
+	{"TEClick", (PyCFunction)TEObj_TEClick, 1,
+	 "(Point pt, Boolean fExtend) -> None"},
+	{"TESetStyleHandle", (PyCFunction)TEObj_TESetStyleHandle, 1,
+	 "(TEStyleHandle theHandle) -> None"},
+	{"TEGetStyleHandle", (PyCFunction)TEObj_TEGetStyleHandle, 1,
+	 "() -> (TEStyleHandle _rv)"},
+	{"TEGetStyle", (PyCFunction)TEObj_TEGetStyle, 1,
+	 "(short offset) -> (TextStyle theStyle, short lineHeight, short fontAscent)"},
+	{"TEStylePaste", (PyCFunction)TEObj_TEStylePaste, 1,
+	 "() -> None"},
+	{"TESetStyle", (PyCFunction)TEObj_TESetStyle, 1,
+	 "(short mode, TextStyle newStyle, Boolean fRedraw) -> None"},
+	{"TEReplaceStyle", (PyCFunction)TEObj_TEReplaceStyle, 1,
+	 "(short mode, TextStyle oldStyle, TextStyle newStyle, Boolean fRedraw) -> None"},
+	{"TEGetStyleScrapHandle", (PyCFunction)TEObj_TEGetStyleScrapHandle, 1,
+	 "() -> (StScrpHandle _rv)"},
+	{"TEStyleInsert", (PyCFunction)TEObj_TEStyleInsert, 1,
+	 "(Buffer text, StScrpHandle hST) -> None"},
+	{"TEGetHeight", (PyCFunction)TEObj_TEGetHeight, 1,
+	 "(long endLine, long startLine) -> (long _rv)"},
+	{"TEContinuousStyle", (PyCFunction)TEObj_TEContinuousStyle, 1,
+	 "(short mode, TextStyle aStyle) -> (Boolean _rv, short mode, TextStyle aStyle)"},
+	{"TEUseStyleScrap", (PyCFunction)TEObj_TEUseStyleScrap, 1,
+	 "(long rangeStart, long rangeEnd, StScrpHandle newStyles, Boolean fRedraw) -> None"},
+	{"TENumStyles", (PyCFunction)TEObj_TENumStyles, 1,
+	 "(long rangeStart, long rangeEnd) -> (long _rv)"},
+	{"TEFeatureFlag", (PyCFunction)TEObj_TEFeatureFlag, 1,
+	 "(short feature, short action) -> (short _rv)"},
+	{NULL, NULL, 0}
+};
+
+PyMethodChain TEObj_chain = { TEObj_methods, NULL };
+
+static PyObject *TEObj_getattr(self, name)
+	TEObject *self;
+	char *name;
+{
+	return Py_FindMethodInChain(&TEObj_chain, (PyObject *)self, name);
+}
+
+#define TEObj_setattr NULL
+
+PyTypeObject TE_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0, /*ob_size*/
+	"TE", /*tp_name*/
+	sizeof(TEObject), /*tp_basicsize*/
+	0, /*tp_itemsize*/
+	/* methods */
+	(destructor) TEObj_dealloc, /*tp_dealloc*/
+	0, /*tp_print*/
+	(getattrfunc) TEObj_getattr, /*tp_getattr*/
+	(setattrfunc) TEObj_setattr, /*tp_setattr*/
+};
+
+/* ----------------------- End object type TE ----------------------- */
+
+
+static PyObject *TE_TEScrapHandle(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = TEScrapHandle();
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *TE_TEGetScrapLength(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = TEGetScrapLength();
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *TE_TENew(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	TEHandle _rv;
+	Rect destRect;
+	Rect viewRect;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetRect, &destRect,
+	                      PyMac_GetRect, &viewRect))
+		return NULL;
+	_rv = TENew(&destRect,
+	            &viewRect);
+	_res = Py_BuildValue("O&",
+	                     TEObj_New, _rv);
+	return _res;
+}
+
+static PyObject *TE_TETextBox(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	char *text__in__;
+	long text__len__;
+	int text__in_len__;
+	Rect box;
+	short just;
+	if (!PyArg_ParseTuple(_args, "s#O&h",
+	                      &text__in__, &text__in_len__,
+	                      PyMac_GetRect, &box,
+	                      &just))
+		return NULL;
+	text__len__ = text__in_len__;
+	TETextBox(text__in__, text__len__,
+	          &box,
+	          just);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+ text__error__: ;
+	return _res;
+}
+
+static PyObject *TE_TEStyleNew(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	TEHandle _rv;
+	Rect destRect;
+	Rect viewRect;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetRect, &destRect,
+	                      PyMac_GetRect, &viewRect))
+		return NULL;
+	_rv = TEStyleNew(&destRect,
+	                 &viewRect);
+	_res = Py_BuildValue("O&",
+	                     TEObj_New, _rv);
+	return _res;
+}
+
+static PyObject *TE_TESetScrapLength(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long length;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &length))
+		return NULL;
+	TESetScrapLength(length);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TE_TEFromScrap(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = TEFromScrap();
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *TE_TEToScrap(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = TEToScrap();
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyMethodDef TE_methods[] = {
+	{"TEScrapHandle", (PyCFunction)TE_TEScrapHandle, 1,
+	 "() -> (Handle _rv)"},
+	{"TEGetScrapLength", (PyCFunction)TE_TEGetScrapLength, 1,
+	 "() -> (long _rv)"},
+	{"TENew", (PyCFunction)TE_TENew, 1,
+	 "(Rect destRect, Rect viewRect) -> (TEHandle _rv)"},
+	{"TETextBox", (PyCFunction)TE_TETextBox, 1,
+	 "(Buffer text, Rect box, short just) -> None"},
+	{"TEStyleNew", (PyCFunction)TE_TEStyleNew, 1,
+	 "(Rect destRect, Rect viewRect) -> (TEHandle _rv)"},
+	{"TESetScrapLength", (PyCFunction)TE_TESetScrapLength, 1,
+	 "(long length) -> None"},
+	{"TEFromScrap", (PyCFunction)TE_TEFromScrap, 1,
+	 "() -> None"},
+	{"TEToScrap", (PyCFunction)TE_TEToScrap, 1,
+	 "() -> None"},
+	{NULL, NULL, 0}
+};
+
+
+
+
+void initTE()
+{
+	PyObject *m;
+	PyObject *d;
+
+
+
+
+	m = Py_InitModule("TE", TE_methods);
+	d = PyModule_GetDict(m);
+	TE_Error = PyMac_GetOSErrException();
+	if (TE_Error == NULL ||
+	    PyDict_SetItemString(d, "Error", TE_Error) != 0)
+		Py_FatalError("can't initialize TE.Error");
+}
+
+/* ========================= End module TE ========================== */
+
diff --git a/Mac/Modules/te/tescan.py b/Mac/Modules/te/tescan.py
new file mode 100644
index 0000000..e7bb74b
--- /dev/null
+++ b/Mac/Modules/te/tescan.py
@@ -0,0 +1,60 @@
+# Scan an Apple header file, generating a Python file of generator calls.
+
+import addpack
+addpack.addpack(':tools:bgen:bgen')
+from scantools import Scanner
+
+LONG = "TextEdit"
+SHORT = "te"
+OBJECT = "TEHandle"
+
+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 [
+			"TEDispose",
+			"TEInit",
+			"TEGetHiliteRgn",
+			]
+
+	def makeblacklisttypes(self):
+		return [
+			"TEClickLoopUPP",
+			"UniversalProcPtr",
+			"WordBreakUPP"
+			]
+
+	def makerepairinstructions(self):
+		return [
+			([("void_ptr", "*", "InMode"), ("long", "*", "InMode")],
+			 [("InBuffer", "*", "*")]),
+			 
+			# TEContinuousStyle
+			([("short", "mode", "OutMode"), ("TextStyle", "aStyle", "OutMode")],
+			 [("short", "mode", "InOutMode"), ("TextStyle", "aStyle", "InOutMode")])
+			]
+			
+if __name__ == "__main__":
+	main()
diff --git a/Mac/Modules/te/tesupport.py b/Mac/Modules/te/tesupport.py
new file mode 100644
index 0000000..eda089c
--- /dev/null
+++ b/Mac/Modules/te/tesupport.py
@@ -0,0 +1,114 @@
+# 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 = 'TextEdit.h'		# The Apple header file
+MODNAME = 'TE'				# The name of the module
+OBJECTNAME = 'TE'			# 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 = "TEHandle"		# 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
+TEHandle = OpaqueByValueType("TEHandle", "TEObj")
+CharsHandle = OpaqueByValueType("CharsHandle", "ResObj")
+##Handle = OpaqueByValueType("Handle", "ResObj")
+StScrpHandle = OpaqueByValueType("StScrpHandle", "ResObj")
+TEStyleHandle = OpaqueByValueType("TEStyleHandle", "ResObj")
+RgnHandle = OpaqueByValueType("RgnHandle", "ResObj")
+
+TextStyle = OpaqueType("TextStyle", "TextStyle")
+TextStyle_ptr = TextStyle
+
+includestuff = includestuff + """
+#include <%s>""" % MACHEADERFILE + """
+
+/* Exported by Qdmodule.c: */
+extern PyObject *QdRGB_New(RGBColor *);
+extern int QdRGB_Convert(PyObject *, RGBColor *);
+
+/*
+** Parse/generate TextStyle records
+*/
+PyObject *TextStyle_New(itself)
+	TextStylePtr itself;
+{
+
+	return Py_BuildValue("lllO&", (long)itself->tsFont, (long)itself->tsFace, (long)itself->tsSize, QdRGB_New,
+				&itself->tsColor);
+}
+
+TextStyle_Convert(v, p_itself)
+	PyObject *v;
+	TextStylePtr p_itself;
+{
+	long font, face, size;
+	
+	if( !PyArg_ParseTuple(v, "lllO&", &font, &face, &size, QdRGB_Convert, &p_itself->tsColor) )
+		return 0;
+	p_itself->tsFont = (short)font;
+	p_itself->tsFace = (Style)face;
+	p_itself->tsSize = (short)size;
+	return 1;
+}
+"""
+
+class TEMethodGenerator(OSErrMethodGenerator):
+	"""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(TE_Error,"Cannot create null TE");
+					return NULL;
+				}""")
+	def outputFreeIt(self, itselfname):
+		Output("TEDispose(%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 = OSErrFunctionGenerator
+Method = TEMethodGenerator
+
+# 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()
+