* doc/text.n: TIP #104 implementation which generalizes the

	* generic/tkText.c:    undo/redo stack to not be tied solely to the
	* generic/tkText.h:    text widget.  The APIs are still private.
	* generic/tkUndo.c:    This also adds a stack limiting ability and
	* generic/tkUndo.h:    a -maxundo option to the text widget (in
	* library/text.tcl:    addition to the options from TIP #26) should
	* mac/tkMacDefault.h:  users want to limit the undo/redo stack
	* tests/text.test:     (should not be necessary in most cases).
	* unix/Makefile.in:    [Patch #554763] (callewart)
	* unix/tkUnixDefault.h:
	* win/Makefile.in:
	* win/makefile.vc:
	* win/tkWinDefault.h:

14 files changed, 686 insertions, 295 deletions

diff --git a/ChangeLog b/ChangeLog
index e1d43d3..777a9db 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,19 @@
+2002-06-21  Jeff Hobbs  <jeffh@ActiveState.com>
+
+	* doc/text.n:          TIP #104 implementation which generalizes the
+	* generic/tkText.c:    undo/redo stack to not be tied solely to the
+	* generic/tkText.h:    text widget.  The APIs are still private.
+	* generic/tkUndo.c:    This also adds a stack limiting ability and
+	* generic/tkUndo.h:    a -maxundo option to the text widget (in
+	* library/text.tcl:    addition to the options from TIP #26) should
+	* mac/tkMacDefault.h:  users want to limit the undo/redo stack
+	* tests/text.test:     (should not be necessary in most cases).
+	* unix/Makefile.in:    [Patch #554763] (callewart)
+	* unix/tkUnixDefault.h:
+	* win/Makefile.in:
+	* win/makefile.vc:
+	* win/tkWinDefault.h:
+
 2002-06-21  Don Porter <dgp@users.sf.net>
 
 	* unix/Makefile.in:	Removed unnecessary dependence of tktest
diff --git a/doc/text.n b/doc/text.n
index 6459170..31c49a5 100644
--- a/doc/text.n
+++ b/doc/text.n
@@ -5,7 +5,7 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
-'\" RCS: @(#) $Id: text.n,v 1.11 2001/11/15 11:55:26 dkf Exp $
+'\" RCS: @(#) $Id: text.n,v 1.12 2002/06/21 23:09:55 hobbs Exp $
 '\" 
 .so man.macros
 .TH text n 4.0 Tk "Tk Built-In Commands"
@@ -32,7 +32,7 @@ text, tk_textCopy, tk_textCut, tk_textPaste \- Create and manipulate text widget
 \-highlightcolor	\-pady	\-yscrollcommand
 .SE
 .SH "WIDGET-SPECIFIC OPTIONS"
-.OP \-autoseparators autoSseparators AutoSeparators
+.OP \-autoseparators autoSeparators AutoSeparators
 .VS 8.4
 Specifies a boolean that says whether separators are automatically
 inserted in the undo stack. Only meaningful when the \fB\-undo\fR
@@ -42,6 +42,9 @@ option is true.
 Specifies the desired height for the window, in units of characters
 in the font given by the \fB\-font\fR option.
 Must be at least one.
+.OP \-maxundo maxUndo MaxUndo
+Specifies the maximum number of compound undo actions on the undo
+stack. A zero or a negative value imply an unlimited undo stack.
 .OP \-spacing1 spacing1 Spacing1
 Requests additional space above each text line in the widget,
 using any of the standard forms for screen distances.
@@ -732,7 +735,7 @@ more details.
 .VS 8.4
 The text widget has an unlimited undo and redo mechanism (when the
 \fB-undo\fR widget option is true) which records every insert and
-delete action is recorded on a stack.
+delete action on a stack.
 .PP
 Boundaries (called "separators") are inserted between edit actions.
 The purpose of these separators is to group inserts and deletes into
@@ -746,13 +749,13 @@ under control.
 Separators are inserted automatically when the \fB-autoseparators\fR
 widget option is true.  You can insert separators programatically as
 well.  If a separator is already present at the top of the undo stack
-no other will inserted.  That means that two separators on the undo
+no other will be inserted.  That means that two separators on the undo
 stack are always separated by at least one insert or delete action.
 .PP
 The undo mechanism is also linked to the modified flag.  This means
 that undoing or redoing changes can take a modified text widget back
 to the unmodified state or vice versa.  The modified flag will be set
-to automatically to the appropriate state.  This automatic coupling
+automatically to the appropriate state.  This automatic coupling
 does not work when the modified flag has been set by the user, until
 the flag has been reset again.
 .PP
diff --git a/generic/tkText.c b/generic/tkText.c
index 2b9c60e..6d5f024 100644
--- a/generic/tkText.c
+++ b/generic/tkText.c
@@ -14,12 +14,13 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkText.c,v 1.26 2002/02/26 01:58:25 hobbs Exp $
+ * RCS: @(#) $Id: tkText.c,v 1.27 2002/06/21 23:09:54 hobbs Exp $
  */
 
 #include "default.h"
 #include "tkPort.h"
 #include "tkInt.h"
+#include "tkUndo.h"
 
 #ifdef MAC_TCL
 #define Style TkStyle
@@ -90,6 +91,8 @@ static Tk_ConfigSpec configSpecs[] = {
 	DEF_TEXT_INSERT_ON_TIME, Tk_Offset(TkText, insertOnTime), 0},
     {TK_CONFIG_PIXELS, "-insertwidth", "insertWidth", "InsertWidth",
 	DEF_TEXT_INSERT_WIDTH, Tk_Offset(TkText, insertWidth), 0},
+    {TK_CONFIG_INT, "-maxundo", "maxUndo", "MaxUndo",
+	DEF_TEXT_MAX_UNDO, Tk_Offset(TkText, maxUndo), 0},
     {TK_CONFIG_PIXELS, "-padx", "padX", "Pad",
 	DEF_TEXT_PADX, Tk_Offset(TkText, padX), 0},
     {TK_CONFIG_PIXELS, "-pady", "padY", "Pad",
@@ -311,18 +314,10 @@ static void		DumpLine _ANSI_ARGS_((Tcl_Interp *interp,
 static int		DumpSegment _ANSI_ARGS_((Tcl_Interp *interp, char *key,
 			    char *value, char * command, TkTextIndex *index,
 			    int what));
-static int		TextEditUndo _ANSI_ARGS_((Tcl_Interp * interp,
-			    TkText *textPtr));
-static int		TextEditRedo _ANSI_ARGS_((Tcl_Interp * interp,
-			    TkText *textPtr));
+static int		TextEditUndo _ANSI_ARGS_((TkText *textPtr));
+static int		TextEditRedo _ANSI_ARGS_((TkText *textPtr));
 static void		TextGetText _ANSI_ARGS_((TkTextIndex * index1,
 			    TkTextIndex * index2, Tcl_DString *dsPtr));
-static void		pushStack _ANSI_ARGS_(( TkTextEditAtom ** stack, 
-			    TkTextEditAtom * elem ));
-
-static TkTextEditAtom * popStack   _ANSI_ARGS_((TkTextEditAtom ** stack));
-static void		clearStack _ANSI_ARGS_((TkTextEditAtom ** stack));
-static void		insertSeparator _ANSI_ARGS_((TkTextEditAtom ** stack));
 static void		updateDirtyFlag _ANSI_ARGS_((TkText *textPtr));
 
 /*
@@ -412,9 +407,11 @@ Tk_TextCmd(clientData, interp, argc, argv)
     TkTextSetYView(textPtr, &startIndex, 0);
     textPtr->exportSelection = 1;
     textPtr->pickEvent.type = LeaveNotify;
+    textPtr->undoStack = TkUndoInitStack(interp,0);
     textPtr->undo = 1;
     textPtr->isDirtyIncrement = 1;
     textPtr->autoSeparators = 1;
+    textPtr->lastEditMode = TK_TEXT_EDIT_OTHER;
 
     /*
      * Create the "sel" tag and the "current" and "insert" marks.
@@ -811,8 +808,7 @@ DestroyText(memPtr)
     if (textPtr->bindingTable != NULL) {
 	Tk_DeleteBindingTable(textPtr->bindingTable);
     }
-    clearStack(&(textPtr->undoStack));
-    clearStack(&(textPtr->redoStack));
+    TkUndoFreeStack(textPtr->undoStack);
 
     /*
      * NOTE: do NOT free up selBorder, selBdString, or selFgColorPtr:
@@ -864,6 +860,8 @@ ConfigureText(interp, textPtr, argc, argv, flags)
 	return TCL_ERROR;
     }
 
+    TkUndoSetDepth(textPtr->undoStack, textPtr->maxUndo);
+
     /*
      * A few other options also need special processing, such as parsing
      * the geometry and setting the background from a 3-D border.
@@ -1193,7 +1191,6 @@ InsertChars(textPtr, indexPtr, string)
 {
     int lineIndex, resetView, offset;
     TkTextIndex newTop;
-    TkTextEditAtom * insertion;
     char indexBuffer[TK_POS_CHARS];
 
     /*
@@ -1229,23 +1226,59 @@ InsertChars(textPtr, indexPtr, string)
      */
 
     if ( textPtr->undo ) {
-        if (textPtr->autoSeparators && textPtr->undoStack &&
-            textPtr->undoStack->type != TK_EDIT_INSERT) {
-            insertSeparator(&(textPtr->undoStack));
+        TkTextIndex     toIndex;
+
+        Tcl_DString actionCommand;
+        Tcl_DString revertCommand;
+        
+        if (textPtr->autoSeparators &&
+            textPtr->lastEditMode != TK_TEXT_EDIT_INSERT) {
+            TkUndoInsertUndoSeparator(textPtr->undoStack);
         }
         
-        insertion = (TkTextEditAtom *) ckalloc(sizeof(TkTextEditAtom));
-        insertion->type = TK_EDIT_INSERT;
+        textPtr->lastEditMode = TK_TEXT_EDIT_INSERT;
         
+        Tcl_DStringInit(&actionCommand);
+        Tcl_DStringInit(&revertCommand);
+        
+        Tcl_DStringAppend(&actionCommand,Tcl_GetCommandName(textPtr->interp,textPtr->widgetCmd),-1);
+        Tcl_DStringAppend(&actionCommand," insert ",-1);
         TkTextPrintIndex(indexPtr,indexBuffer);
-        insertion->index = (char *) ckalloc(strlen(indexBuffer) + 1);
-        strcpy(insertion->index,indexBuffer);
+        Tcl_DStringAppend(&actionCommand,indexBuffer,-1);
+        Tcl_DStringAppend(&actionCommand," ",-1);
+        Tcl_DStringAppendElement(&actionCommand,string);
+        Tcl_DStringAppend(&actionCommand,";",-1);
+        Tcl_DStringAppend(&actionCommand,Tcl_GetCommandName(textPtr->interp,textPtr->widgetCmd),-1);
+        Tcl_DStringAppend(&actionCommand," mark set insert ",-1);
+        TkTextIndexForwBytes(indexPtr, (int) strlen(string),
+			&toIndex);
+        TkTextPrintIndex(&toIndex, indexBuffer);
+        Tcl_DStringAppend(&actionCommand,indexBuffer,-1);
+        Tcl_DStringAppend(&actionCommand,"; ",-1);
+        Tcl_DStringAppend(&actionCommand,Tcl_GetCommandName(textPtr->interp,textPtr->widgetCmd),-1);
+        Tcl_DStringAppend(&actionCommand," see insert",-1);
         
-        insertion->string = (char *) ckalloc(strlen(string) + 1);
-        strcpy(insertion->string,string);
+        Tcl_DStringAppend(&revertCommand,Tcl_GetCommandName(textPtr->interp,textPtr->widgetCmd),-1);
+        Tcl_DStringAppend(&revertCommand," delete ",-1);
+        TkTextPrintIndex(indexPtr,indexBuffer);
+        Tcl_DStringAppend(&revertCommand,indexBuffer,-1);
+        Tcl_DStringAppend(&revertCommand," ",-1);
+        TkTextPrintIndex(&toIndex, indexBuffer);
+        Tcl_DStringAppend(&revertCommand,indexBuffer,-1);
+        Tcl_DStringAppend(&revertCommand," ;",-1);
+        Tcl_DStringAppend(&revertCommand,Tcl_GetCommandName(textPtr->interp,textPtr->widgetCmd),-1);
+        Tcl_DStringAppend(&revertCommand," mark set insert ",-1);
+        TkTextPrintIndex(indexPtr,indexBuffer);
+        Tcl_DStringAppend(&revertCommand,indexBuffer,-1);
+        Tcl_DStringAppend(&revertCommand,"; ",-1);
+        Tcl_DStringAppend(&revertCommand,Tcl_GetCommandName(textPtr->interp,textPtr->widgetCmd),-1);
+        Tcl_DStringAppend(&revertCommand," see insert",-1);
+        
+        TkUndoPushAction(textPtr->undoStack,&actionCommand, &revertCommand);
+
+     	Tcl_DStringFree(&actionCommand);
+     	Tcl_DStringFree(&revertCommand);
 
-        pushStack(&(textPtr->undoStack),insertion);
-        clearStack(&(textPtr->redoStack));
     }
     updateDirtyFlag(textPtr);
 
@@ -1292,7 +1325,6 @@ DeleteChars(textPtr, index1String, index2String)
 {
     int line1, line2, line, byteIndex, resetView;
     TkTextIndex index1, index2;
-    TkTextEditAtom * deletion;
     char indexBuffer[TK_POS_CHARS];
 
     /*
@@ -1412,27 +1444,58 @@ DeleteChars(textPtr, index1String, index2String)
 
     if (textPtr->undo) {
 	Tcl_DString ds;
-
-	if (textPtr->autoSeparators && (textPtr->undoStack != NULL)
-		&& (textPtr->undoStack->type != TK_EDIT_DELETE)) {
-	   insertSeparator(&(textPtr->undoStack));
+        Tcl_DString actionCommand;
+        Tcl_DString revertCommand;
+    
+	if (textPtr->autoSeparators
+		&& (textPtr->lastEditMode != TK_TEXT_EDIT_DELETE)) {
+	   TkUndoInsertUndoSeparator(textPtr->undoStack);
 	}
 
-	deletion = (TkTextEditAtom *) ckalloc(sizeof(TkTextEditAtom));
-	deletion->type = TK_EDIT_DELETE;
+	textPtr->lastEditMode = TK_TEXT_EDIT_DELETE;
+
+        Tcl_DStringInit(&actionCommand);
+        Tcl_DStringInit(&revertCommand);
 
-	TkTextPrintIndex(&index1, indexBuffer);
-	deletion->index = (char *) ckalloc(strlen(indexBuffer) + 1);
-	strcpy(deletion->index, indexBuffer);
+        Tcl_DStringAppend(&actionCommand,Tcl_GetCommandName(textPtr->interp,textPtr->widgetCmd),-1);
+        Tcl_DStringAppend(&actionCommand," delete ",-1);
+        TkTextPrintIndex(&index1,indexBuffer);
+        Tcl_DStringAppend(&actionCommand,indexBuffer,-1);
+        Tcl_DStringAppend(&actionCommand," ",-1);
+        TkTextPrintIndex(&index2, indexBuffer);
+        Tcl_DStringAppend(&actionCommand,indexBuffer,-1);
+        Tcl_DStringAppend(&actionCommand,"; ",-1);
+        Tcl_DStringAppend(&actionCommand,Tcl_GetCommandName(textPtr->interp,textPtr->widgetCmd),-1);
+        Tcl_DStringAppend(&actionCommand," mark set insert ",-1);
+        TkTextPrintIndex(&index1,indexBuffer);
+        Tcl_DStringAppend(&actionCommand,indexBuffer,-1);
+
+        Tcl_DStringAppend(&actionCommand,"; ",-1);
+        Tcl_DStringAppend(&actionCommand,Tcl_GetCommandName(textPtr->interp,textPtr->widgetCmd),-1);
+        Tcl_DStringAppend(&actionCommand," see insert",-1);
 
 	TextGetText(&index1, &index2, &ds);
-	deletion->string =
-	    (char *) ckalloc((unsigned int) Tcl_DStringLength(&ds) + 1);
-	strcpy(deletion->string, Tcl_DStringValue(&ds));
-	Tcl_DStringFree(&ds);
 
-	pushStack(&(textPtr->undoStack), deletion);
-	clearStack(&(textPtr->redoStack));
+        Tcl_DStringAppend(&revertCommand,Tcl_GetCommandName(textPtr->interp,textPtr->widgetCmd),-1);
+        Tcl_DStringAppend(&revertCommand," insert ",-1);
+        TkTextPrintIndex(&index1,indexBuffer);
+        Tcl_DStringAppend(&revertCommand,indexBuffer,-1);
+        Tcl_DStringAppend(&revertCommand," ",-1);
+        Tcl_DStringAppendElement(&revertCommand,Tcl_DStringValue(&ds));
+        Tcl_DStringAppend(&revertCommand,"; ",-1);
+        Tcl_DStringAppend(&revertCommand,Tcl_GetCommandName(textPtr->interp,textPtr->widgetCmd),-1);
+        Tcl_DStringAppend(&revertCommand," mark set insert ",-1);
+        TkTextPrintIndex(&index2, indexBuffer);
+        Tcl_DStringAppend(&revertCommand,indexBuffer,-1);
+        Tcl_DStringAppend(&revertCommand,"; ",-1);
+        Tcl_DStringAppend(&revertCommand,Tcl_GetCommandName(textPtr->interp,textPtr->widgetCmd),-1);
+        Tcl_DStringAppend(&revertCommand," see insert",-1);
+
+        TkUndoPushAction(textPtr->undoStack,&actionCommand, &revertCommand);
+
+        Tcl_DStringFree(&actionCommand);
+        Tcl_DStringFree(&revertCommand);
+
     }
     updateDirtyFlag(textPtr);
 
@@ -2483,98 +2546,6 @@ DumpSegment(interp, key, value, command, index, what)
 }
 
 /*
- * pushStack
- *    Push elem on the stack identified by stack.
- *
- * Results:
- *    None
- *
- * Side effects:
- *    None.
- */
- 
-static void pushStack ( stack, elem )
-    TkTextEditAtom ** stack;
-    TkTextEditAtom *  elem;
-{ 
-    elem->next = *stack;
-    *stack = elem;
-}
-
-/*
- * popStack --
- *    Remove and return the top element from the stack identified by 
- *      stack.
- *
- * Results:
- *    None
- *
- * Side effects:
- *    None.
- */
- 
-static TkTextEditAtom * popStack ( stack )
-    TkTextEditAtom ** stack ;
-{ 
-    TkTextEditAtom * elem = NULL;
-    if (*stack != NULL ) {
-        elem   = *stack;
-        *stack = elem->next;
-    }
-    return elem;
-}
-
-/*
- * insertSeparator --
- *    insert a separator on the stack, indicating a border for
- *      an undo/redo chunk.
- *
- * Results:
- *    None
- *
- * Side effects:
- *    None.
- */
- 
-static void insertSeparator ( stack )
-    TkTextEditAtom ** stack;
-{
-    TkTextEditAtom * separator;
-
-    if ( *stack != NULL && (*stack)->type != TK_EDIT_SEPARATOR ) {
-        separator = (TkTextEditAtom *) ckalloc(sizeof(TkTextEditAtom));
-        separator->type = TK_EDIT_SEPARATOR;
-        pushStack(stack,separator);
-    }
-}
-
-/*
- * clearStack --
- *    Clear an entire undo or redo stack and destroy all elements in it.
- *
- * Results:
- *    None
- *
- * Side effects:
- *    None.
- */
-
-static void clearStack ( stack )
-    TkTextEditAtom ** stack;      /* An Undo or Redo stack */
-{
-    TkTextEditAtom * elem;
-
-    while ( (elem = popStack(stack)) ) {
-        if ( elem->type != TK_EDIT_SEPARATOR ) {
-            ckfree(elem->index);
-            ckfree(elem->string);
-        }
-        ckfree((char *)elem);
-    }
-    *stack = NULL;
-}
-
-/*
  * TextEditUndo --
  *    undo the last change.
  *
@@ -2585,14 +2556,10 @@ static void clearStack ( stack )
  *    None.
  */
  
-static int TextEditUndo (interp,textPtr)
-    Tcl_Interp * interp;
+static int TextEditUndo (textPtr)
     TkText     * textPtr;          /* Overall information about text widget. */
 {
-    TkTextEditAtom * elem;
-    TkTextIndex      fromIndex, toIndex;
-    char             buffer[TK_POS_CHARS];
-    char             viewIndex[TK_POS_CHARS];
+    int status;
     
     if ( ! textPtr->undo ) {
        return TCL_OK;
@@ -2602,64 +2569,15 @@ static int TextEditUndo (interp,textPtr)
 
     textPtr->undo = 0;
 
-    /* insert a separator on the redo stack */
+    /* revert one compound action */
 
-    insertSeparator(&(textPtr->redoStack));
+    status = TkUndoRevert(textPtr->undoStack);
 
-    /* Pop and skip the first separator if there is one*/
-
-    elem = popStack(&(textPtr->undoStack));
-
-    if ( elem == NULL ) {
-        textPtr->undo = 1;
-        return TCL_ERROR;
-    }
-
-    if ( ( elem != NULL ) && ( elem->type == TK_EDIT_SEPARATOR ) ) {
-        ckfree((char *) elem);
-        elem = popStack(&(textPtr->undoStack));
-    }
-    
-    while ( elem && (elem->type != TK_EDIT_SEPARATOR) ) {
-        switch ( elem->type ) {
-            case TK_EDIT_INSERT:
-                TkTextGetIndex(interp,textPtr,elem->index,&toIndex);
-                strcpy(viewIndex,elem->index);
-                TkTextIndexForwBytes(&toIndex,(int)strlen(elem->string),&toIndex);
-                TkTextPrintIndex(&toIndex,buffer);
-                textPtr->isDirtyIncrement = -1;
-                DeleteChars(textPtr,elem->index,buffer);
-                textPtr->isDirtyIncrement = 1;
-                break;
-            case TK_EDIT_DELETE: 
-                TkTextGetIndex(interp,textPtr,elem->index,&fromIndex);
-                textPtr->isDirtyIncrement = -1;
-                InsertChars(textPtr,&fromIndex,elem->string);
-                TkTextIndexForwBytes(&fromIndex,(int)strlen(elem->string),&toIndex);
-                TkTextPrintIndex(&toIndex,viewIndex);
-                textPtr->isDirtyIncrement = 1;
-                break;
-            default:
-                return TCL_ERROR;
-        }
-        pushStack(&(textPtr->redoStack),elem);
-        elem = popStack(&(textPtr->undoStack));
-    }
-    
-    /* view the last changed position */
-    
-    TkTextGetIndex(interp,textPtr,viewIndex,&toIndex);
-    TkTextSetMark(textPtr, "insert", &toIndex);
-
-    /* insert a separator on the undo stack */
-    
-    insertSeparator(&(textPtr->undoStack));
-    
     /* Turn back on the undo feature */
     
     textPtr->undo = 1;
     
-    return TCL_OK;
+    return status;
 }
 
 /*
@@ -2673,14 +2591,10 @@ static int TextEditUndo (interp,textPtr)
  *    None.
  */
 
-static int TextEditRedo (interp,textPtr)
-    Tcl_Interp * interp;
+static int TextEditRedo (textPtr)
     TkText     * textPtr;       /* Overall information about text widget. */
 {
-    TkTextEditAtom *elem;
-    TkTextIndex     fromIndex, toIndex;
-    char            buffer[TK_POS_CHARS];
-    char            viewIndex[TK_POS_CHARS];
+    int status;
 
     if (!textPtr->undo) {
        return TCL_OK;
@@ -2690,62 +2604,15 @@ static int TextEditRedo (interp,textPtr)
 
     textPtr->undo = 0;
 
-    /* insert a separator on the undo stack */
-
-    insertSeparator(&(textPtr->undoStack));
-
-    /* Pop and skip the first separator if there is one*/
-
-    elem = popStack(&(textPtr->redoStack));
-
-    if ( elem == NULL ) {
-       textPtr->undo = 1;
-       return TCL_ERROR;
-    }
-
-    if ( ( elem != NULL ) && ( elem->type == TK_EDIT_SEPARATOR ) ) {
-        ckfree((char *) elem);
-        elem = popStack(&(textPtr->redoStack));
-    }
-
-    while ( elem && (elem->type != TK_EDIT_SEPARATOR) ) {
-        switch ( elem->type ) {
-            case TK_EDIT_INSERT:
-                TkTextGetIndex(interp, textPtr, elem->index, &fromIndex);
-                InsertChars(textPtr, &fromIndex, elem->string);
-                TkTextIndexForwBytes(&fromIndex, (int) strlen(elem->string),
-			&toIndex);
-                TkTextPrintIndex(&toIndex, viewIndex);
-                break;
-            case TK_EDIT_DELETE: 
-                TkTextGetIndex(interp, textPtr, elem->index, &toIndex);
-                strcpy(viewIndex, elem->index);
-                TkTextIndexForwBytes(&toIndex, (int) strlen(elem->string),
-			&toIndex);
-                TkTextPrintIndex(&toIndex, buffer);
-                DeleteChars(textPtr, elem->index, buffer);
-                break;
-            default:
-                return TCL_ERROR;
-        }
-        pushStack(&(textPtr->undoStack), elem);
-        elem = popStack(&(textPtr->redoStack));
-    }
-
-    /* view the last changed position */
+    /* reapply one compound action */
 
-    TkTextGetIndex(interp, textPtr, viewIndex, &toIndex);
-    TkTextSetMark(textPtr, "insert", &toIndex);
-
-    /* insert a separator on the undo stack */
-    
-    insertSeparator(&(textPtr->undoStack));
+    status = TkUndoApply(textPtr->undoStack);
 
     /* Turn back on the undo feature */
     
     textPtr->undo = 1;
     
-    return TCL_OK;
+    return status;
 }
 
 /*
@@ -2823,7 +2690,7 @@ TextEditCmd(textPtr, interp, argc, argv)
 		    argv[0], " edit redo\"", (char *) NULL);
 	    return TCL_ERROR;
 	}
-        if ( TextEditRedo(interp,textPtr) ) {
+        if ( TextEditRedo(textPtr) ) {
             Tcl_AppendResult(interp, "nothing to redo", (char *) NULL);
 	    return TCL_ERROR;
         }
@@ -2834,22 +2701,21 @@ TextEditCmd(textPtr, interp, argc, argv)
 		    argv[0], " edit reset\"", (char *) NULL);
 	    return TCL_ERROR;
 	}
-        clearStack(&(textPtr->undoStack));
-        clearStack(&(textPtr->redoStack));
+        TkUndoClearStacks(textPtr->undoStack);
     } else if ((c == 's') && (strncmp(argv[2], "separator", length) == 0)) {
 	if (argc != 3) {
 	    Tcl_AppendResult(interp, "wrong # args: should be \"",
 		    argv[0], " edit separator\"", (char *) NULL);
 	    return TCL_ERROR;
 	}
-        insertSeparator(&(textPtr->undoStack));
+        TkUndoInsertUndoSeparator(textPtr->undoStack);
     } else if ((c == 'u') && (strncmp(argv[2], "undo", length) == 0)) {
 	if (argc != 3) {
 	    Tcl_AppendResult(interp, "wrong # args: should be \"",
 		    argv[0], " edit undo\"", (char *) NULL);
 	    return TCL_ERROR;
 	}
-        if ( TextEditUndo(interp,textPtr) ) {
+        if ( TextEditUndo(textPtr) ) {
             Tcl_AppendResult(interp, "nothing to undo",
 		    (char *) NULL);
 	    return TCL_ERROR;
diff --git a/generic/tkText.h b/generic/tkText.h
index 79e5220..0937b8f 100644
--- a/generic/tkText.h
+++ b/generic/tkText.h
@@ -10,7 +10,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkText.h,v 1.10 2002/01/25 21:09:37 dgp Exp $
+ * RCS: @(#) $Id: tkText.h,v 1.11 2002/06/21 23:09:54 hobbs Exp $
  */
 
 #ifndef _TKTEXT
@@ -20,6 +20,10 @@
 #include "tk.h"
 #endif
 
+#ifndef _TKUNDO
+#include "tkUndo.h"
+#endif
+
 #ifdef BUILD_tk
 # undef TCL_STORAGE_CLASS
 # define TCL_STORAGE_CLASS DLLEXPORT
@@ -451,24 +455,13 @@ typedef struct TkTextTabArray {
 					 * BE THE LAST IN THE STRUCTURE. */
 } TkTextTabArray;
 
-/* enum definining the types used in an edit stack */
+/* enum definining the edit modes of */
 
 typedef enum {
-    TK_EDIT_SEPARATOR,			/* Marker */
-    TK_EDIT_INSERT,			/* The undo is an insert */
-    TK_EDIT_DELETE			/* The undo is a delete */
-} TkTextEditType;
-
-/* strcut defining the basic undo/redo stack element */
-
-typedef struct TkTextEditAtom {
-    TkTextEditType type;		/* The type that will trigger the
-					 * required action*/
-    char * index;			/* The starting index of the range */
-    char * string;			/* The text to be inserted / deleted */
-    struct TkTextEditAtom * next;	/* Pointer to the next element in the
-					 * stack */
-} TkTextEditAtom;
+    TK_TEXT_EDIT_INSERT,			/* insert mode */
+    TK_TEXT_EDIT_DELETE,			/* delete mode */
+    TK_TEXT_EDIT_OTHER			   /* none of the above */
+} TkTextEditMode;
 
 /*
  * A data structure of the following type is kept for each text widget that
@@ -649,13 +642,14 @@ typedef struct TkText {
      * Information related to the undo/redo functonality
      */
      
-    TkTextEditAtom * undoStack; /* The undo stack */
-    
-    TkTextEditAtom * redoStack; /* The redo stack */
+    TkUndoRedoStack * undoStack; /* The undo/redo stack */
     
     int undo;			/* non zero means the undo/redo behaviour is 
 				 * enabled */
     
+    int maxUndo;		/* The maximum depth of the undo stack expressed
+             * as the maximum number of compound statements */
+
     int autoSeparators;		/* non zero means the separatorss will be 
 				 * inserted automatically */
     
@@ -672,6 +666,9 @@ typedef struct TkText {
 				 * incremented every edit action
 				 */
 
+    TkTextEditMode lastEditMode;	/* Keeps track of what the last edit mode was
+				 */
+
 } TkText;
 
 /*
diff --git a/generic/tkUndo.c b/generic/tkUndo.c
new file mode 100644
index 0000000..eb6f07b
--- /dev/null
+++ b/generic/tkUndo.c
@@ -0,0 +1,400 @@
+/* 
+ * tkUndo.c --
+ *
+ *	This module provides the implementation of an undo stack.
+ *
+ * Copyright (c) 2002 by Ludwig Callewaert.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: tkUndo.c,v 1.1 2002/06/21 23:09:55 hobbs Exp $
+ */
+
+#include "tkUndo.h"
+
+
+/*
+ * TkUndoPushStack
+ *    Push elem on the stack identified by stack.
+ *
+ * Results:
+ *    None
+ *
+ * Side effects:
+ *    None.
+ */
+ 
+void TkUndoPushStack ( stack, elem )
+    TkUndoAtom ** stack;
+    TkUndoAtom *  elem;
+{ 
+    elem->next = *stack;
+    *stack = elem;
+}
+
+/*
+ * TkUndoPopStack --
+ *    Remove and return the top element from the stack identified by 
+ *      stack.
+ *
+ * Results:
+ *    None
+ *
+ * Side effects:
+ *    None.
+ */
+ 
+TkUndoAtom * TkUndoPopStack ( stack )
+    TkUndoAtom ** stack ;
+{ 
+    TkUndoAtom * elem = NULL;
+    if (*stack != NULL ) {
+        elem   = *stack;
+        *stack = elem->next;
+    }
+    return elem;
+}
+
+/*
+ * TkUndoInsertSeparator --
+ *    insert a separator on the stack, indicating a border for
+ *      an undo/redo chunk.
+ *
+ * Results:
+ *    None
+ *
+ * Side effects:
+ *    None.
+ */
+ 
+int TkUndoInsertSeparator ( stack )
+    TkUndoAtom ** stack;
+{
+    TkUndoAtom * separator;
+
+    if ( *stack != NULL && (*stack)->type != TK_UNDO_SEPARATOR ) {
+        separator = (TkUndoAtom *) ckalloc(sizeof(TkUndoAtom));
+        separator->type = TK_UNDO_SEPARATOR;
+        TkUndoPushStack(stack,separator);
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+/*
+ * TkUndoClearStack --
+ *    Clear an entire undo or redo stack and destroy all elements in it.
+ *
+ * Results:
+ *    None
+ *
+ * Side effects:
+ *    None.
+ */
+
+void TkUndoClearStack ( stack )
+    TkUndoAtom ** stack;      /* An Undo or Redo stack */
+{
+    TkUndoAtom * elem;
+
+    while ( (elem = TkUndoPopStack(stack)) ) {
+        if ( elem->type != TK_UNDO_SEPARATOR ) {
+            Tcl_DecrRefCount(elem->apply);
+            Tcl_DecrRefCount(elem->revert);
+        }
+        ckfree((char *)elem);
+    }
+    *stack = NULL;
+}
+
+/*
+ * TkUndoPushAction
+ *    Push a new elem on the stack identified by stack.
+ *    action and revert are given through Tcl_DStrings
+ *
+ * Results:
+ *    None
+ *
+ * Side effects:
+ *    None.
+ */
+ 
+void TkUndoPushAction ( stack, actionScript, revertScript )
+    TkUndoRedoStack * stack;      /* An Undo or Redo stack */
+    Tcl_DString * actionScript; /* The script to get the action (redo) */
+    Tcl_DString * revertScript; /* The script to revert the action (undo) */
+{ 
+    TkUndoAtom * atom;
+
+    atom = (TkUndoAtom *) ckalloc(sizeof(TkUndoAtom));
+    atom->type = TK_UNDO_ACTION;
+
+    atom->apply = Tcl_NewStringObj(Tcl_DStringValue(actionScript),Tcl_DStringLength(actionScript));
+    Tcl_IncrRefCount(atom->apply);
+
+    atom->revert = Tcl_NewStringObj(Tcl_DStringValue(revertScript),Tcl_DStringLength(revertScript));
+    Tcl_IncrRefCount(atom->revert);
+
+    TkUndoPushStack(&(stack->undoStack), atom);
+    TkUndoClearStack(&(stack->redoStack));
+}
+
+
+/*
+ * TkUndoInitStack
+ *    Initialize a new undo/redo stack
+ *
+ * Results:
+ *    un Undo/Redo stack pointer
+ *
+ * Side effects:
+ *    None.
+ */
+ 
+TkUndoRedoStack * TkUndoInitStack ( interp, maxdepth )
+    Tcl_Interp * interp;          /* The interpreter */
+    int          maxdepth;        /* The maximum stack depth */
+{ 
+    TkUndoRedoStack * stack;      /* An Undo/Redo stack */
+    stack = (TkUndoRedoStack *) ckalloc(sizeof(TkUndoRedoStack));
+    stack->undoStack = NULL;
+    stack->redoStack = NULL;
+    stack->interp    = interp;
+    stack->maxdepth  = maxdepth; 
+    stack->depth     = 0;
+    return stack;
+}
+
+
+/*
+ * TkUndoInitStack
+ *    Initialize a new undo/redo stack
+ *
+ * Results:
+ *    un Undo/Redo stack pointer
+ *
+ * Side effects:
+ *    None.
+ */
+ 
+void TkUndoSetDepth ( stack, maxdepth )
+    TkUndoRedoStack * stack;           /* An Undo/Redo stack */
+    int               maxdepth;        /* The maximum stack depth */
+{
+    TkUndoAtom * elem;
+    TkUndoAtom * prevelem;
+    int sepNumber = 0;
+    
+    stack->maxdepth = maxdepth;
+
+    if ((stack->maxdepth > 0) && (stack->depth > stack->maxdepth)) {
+        /* Maximum stack depth exceeded. We have to remove the last compound
+           elements on the stack */
+        elem = stack->undoStack;
+        prevelem = NULL;
+        while ( sepNumber <= stack->maxdepth ) {
+            if (elem != NULL && (elem->type == TK_UNDO_SEPARATOR) ) {
+                sepNumber++;
+            }
+            prevelem = elem;
+            elem = elem->next;
+        }
+        prevelem->next = NULL;
+        while ( elem ) {
+           prevelem = elem;
+           elem = elem->next;
+           ckfree((char *) elem);
+        }
+        stack->depth = stack->maxdepth;
+    }
+}
+
+
+/*
+ * TkUndoClearStacks
+ *    Clear both the undo and redo stack
+ *
+ * Results:
+ *    None
+ *
+ * Side effects:
+ *    None.
+ */
+ 
+void TkUndoClearStacks ( stack )
+    TkUndoRedoStack * stack;      /* An Undo/Redo stack */
+{ 
+    TkUndoClearStack(&(stack->undoStack));
+    TkUndoClearStack(&(stack->redoStack));
+    stack->depth = 0;
+}
+
+
+/*
+ * TkUndoFreeStack
+ *    Clear both the undo and redo stack
+ *    also free the memory allocated to the u/r stack pointer
+ *
+ * Results:
+ *    None
+ *
+ * Side effects:
+ *    None.
+ */
+ 
+void TkUndoFreeStack ( stack )
+    TkUndoRedoStack * stack;      /* An Undo/Redo stack */
+{ 
+   TkUndoClearStacks(stack);
+/*   ckfree((TkUndoRedoStack *) stack); */
+   ckfree((char *) stack);
+}
+
+
+/*
+ * TkUndoInsertUndoSeparator --
+ *    insert a separator on the undo stack, indicating a border for
+ *      an undo/redo chunk.
+ *
+ * Results:
+ *    None
+ *
+ * Side effects:
+ *    None.
+ */
+ 
+void TkUndoInsertUndoSeparator ( stack )
+    TkUndoRedoStack * stack;
+{
+/*    TkUndoAtom * elem;
+    TkUndoAtom * prevelem;
+    int sepNumber = 0;
+*/
+    
+    if ( TkUndoInsertSeparator(&(stack->undoStack)) ) {
+        ++(stack->depth);
+        TkUndoSetDepth(stack,stack->maxdepth);
+/*        if ((stack->maxdepth > 0) && (stack->depth > stack->maxdepth)) {
+            elem = stack->undoStack;
+            prevelem = NULL;
+            while ( sepNumber < stack->depth ) {
+                if (elem != NULL && (elem->type == TK_UNDO_SEPARATOR) ) {
+                    sepNumber++;
+                }
+                prevelem = elem;
+                elem = elem->next;
+            }
+            prevelem->next = NULL;
+            while ( elem ) {
+               prevelem = elem;
+               elem = elem->next;
+               ckfree((char *) elem);
+            }
+            stack->depth;
+        } */
+    }
+}
+
+
+/*
+ * TkUndoRevert --
+ *    Undo a compound action on the stack.
+ *
+ * Results:
+ *    A TCL status code
+ *
+ * Side effects:
+ *    None.
+ */
+ 
+int TkUndoRevert ( stack )
+    TkUndoRedoStack * stack;
+{
+    TkUndoAtom * elem;
+
+    /* insert a separator on the undo and the redo stack */
+
+    TkUndoInsertUndoSeparator(stack);
+    TkUndoInsertSeparator(&(stack->redoStack));
+
+    /* Pop and skip the first separator if there is one*/
+
+    elem = TkUndoPopStack(&(stack->undoStack));
+
+    if ( elem == NULL ) {
+        return TCL_ERROR;
+    }
+
+    if ( ( elem != NULL ) && ( elem->type == TK_UNDO_SEPARATOR ) ) {
+        ckfree((char *) elem);
+        elem = TkUndoPopStack(&(stack->undoStack));
+    }
+    
+    while ( elem && (elem->type != TK_UNDO_SEPARATOR) ) {
+        Tcl_EvalObjEx(stack->interp,elem->revert,TCL_EVAL_GLOBAL);
+        
+        TkUndoPushStack(&(stack->redoStack),elem);
+        elem = TkUndoPopStack(&(stack->undoStack));
+    }
+    
+    /* insert a separator on the redo stack */
+    
+    TkUndoInsertSeparator(&(stack->redoStack));
+    
+    --(stack->depth);
+    
+    return TCL_OK;
+}
+
+
+/*
+ * TkUndoApply --
+ *    Redo a compound action on the stack.
+ *
+ * Results:
+ *    A TCL status code
+ *
+ * Side effects:
+ *    None.
+ */
+ 
+int TkUndoApply ( stack )
+    TkUndoRedoStack * stack;
+{
+    TkUndoAtom *elem;
+
+    /* insert a separator on the undo stack */
+
+    TkUndoInsertSeparator(&(stack->undoStack));
+
+    /* Pop and skip the first separator if there is one*/
+
+    elem = TkUndoPopStack(&(stack->redoStack));
+
+    if ( elem == NULL ) {
+       return TCL_ERROR;
+    }
+
+    if ( ( elem != NULL ) && ( elem->type == TK_UNDO_SEPARATOR ) ) {
+        ckfree((char *) elem);
+        elem = TkUndoPopStack(&(stack->redoStack));
+    }
+
+    while ( elem && (elem->type != TK_UNDO_SEPARATOR) ) {
+        Tcl_EvalObjEx(stack->interp,elem->apply,TCL_EVAL_GLOBAL);
+        
+        TkUndoPushStack(&(stack->undoStack), elem);
+        elem = TkUndoPopStack(&(stack->redoStack));
+    }
+
+    /* insert a separator on the undo stack */
+    
+    TkUndoInsertSeparator(&(stack->undoStack));
+
+    ++(stack->depth);
+    
+    return TCL_OK;
+}
+
diff --git a/generic/tkUndo.h b/generic/tkUndo.h
new file mode 100644
index 0000000..4776b3d
--- /dev/null
+++ b/generic/tkUndo.h
@@ -0,0 +1,90 @@
+/*
+ * tkUndo.h --
+ *
+ *	Declarations shared among the files that implement an undo
+ *	stack.
+ *
+ * Copyright (c) 2002 Ludwig Callewaert.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: tkUndo.h,v 1.1 2002/06/21 23:09:55 hobbs Exp $
+ */
+
+#ifndef _TKUNDO
+#define _TKUNDO
+
+#ifndef _TK
+#include "tk.h"
+#endif
+
+#ifdef BUILD_tk
+# undef TCL_STORAGE_CLASS
+# define TCL_STORAGE_CLASS DLLEXPORT
+#endif
+
+/* enum definining the types used in an undo stack */
+
+typedef enum {
+    TK_UNDO_SEPARATOR,			/* Marker */
+    TK_UNDO_ACTION			   /* Command */
+} TkUndoAtomType;
+
+/* struct defining the basic undo/redo stack element */
+
+typedef struct TkUndoAtom {
+    TkUndoAtomType type;		 /* The type that will trigger the
+					 * required action*/
+    Tcl_Obj * apply;			   /* Command to apply the action that was taken */
+    Tcl_Obj * revert;			/* The command to undo the action */
+    struct TkUndoAtom * next;	/* Pointer to the next element in the
+					 * stack */
+} TkUndoAtom;
+
+/* struct defining the basic undo/redo stack element */
+
+typedef struct TkUndoRedoStack {
+    TkUndoAtom * undoStack;		 /* The undo stack */
+    TkUndoAtom * redoStack;		 /* The redo stack */
+    Tcl_Interp * interp   ;       /* The interpreter in which to execute the revert and apply scripts */
+    int          maxdepth;
+    int          depth;
+} TkUndoRedoStack;
+
+/* basic functions */
+
+EXTERN void TkUndoPushStack  _ANSI_ARGS_((TkUndoAtom ** stack,
+    TkUndoAtom *  elem));
+
+EXTERN TkUndoAtom * TkUndoPopStack _ANSI_ARGS_((TkUndoAtom ** stack));
+ 
+EXTERN int TkUndoInsertSeparator _ANSI_ARGS_((TkUndoAtom ** stack));
+
+EXTERN void TkUndoClearStack _ANSI_ARGS_((TkUndoAtom ** stack));
+
+/* functions working on an undo/redo stack */
+
+EXTERN TkUndoRedoStack * TkUndoInitStack _ANSI_ARGS_((Tcl_Interp * interp,
+    int maxdepth));
+
+EXTERN void TkUndoSetDepth _ANSI_ARGS_((TkUndoRedoStack * stack,
+    int maxdepth));
+
+EXTERN void TkUndoClearStacks _ANSI_ARGS_((TkUndoRedoStack * stack));
+
+EXTERN void TkUndoFreeStack _ANSI_ARGS_((TkUndoRedoStack * stack));
+
+EXTERN void TkUndoInsertUndoSeparator _ANSI_ARGS_((TkUndoRedoStack * stack));
+
+EXTERN void TkUndoPushAction _ANSI_ARGS_((TkUndoRedoStack * stack,
+    Tcl_DString * actionScript, Tcl_DString * revertScript));
+
+EXTERN int TkUndoRevert _ANSI_ARGS_((TkUndoRedoStack *  stack));
+ 
+EXTERN int TkUndoApply _ANSI_ARGS_((TkUndoRedoStack *  stack));
+
+# undef TCL_STORAGE_CLASS
+# define TCL_STORAGE_CLASS DLLIMPORT
+
+#endif /* _TKUNDO */
diff --git a/library/text.tcl b/library/text.tcl
index bc32264..623b2e1 100644
--- a/library/text.tcl
+++ b/library/text.tcl
@@ -3,7 +3,7 @@
 # This file defines the default bindings for Tk text widgets and provides
 # procedures that help in implementing the bindings.
 #
-# RCS: @(#) $Id: text.tcl,v 1.22 2002/03/07 11:49:49 dkf Exp $
+# RCS: @(#) $Id: text.tcl,v 1.23 2002/06/21 23:09:55 hobbs Exp $
 #
 # Copyright (c) 1992-1994 The Regents of the University of California.
 # Copyright (c) 1994-1997 Sun Microsystems, Inc.
@@ -339,15 +339,11 @@ bind Text <Control-t> {
 }
 
 bind Text <<Undo>> {
-    if { ! [ catch { %W edit undo } ] } {
-       %W see insert
-    }
+    catch { %W edit undo }
 }
 
 bind Text <<Redo>> {
-    if { ! [ catch { %W edit redo } ] } {
-       %W see insert
-    }
+    catch { %W edit redo }
 }
 
 if {[string compare $tcl_platform(platform) "windows"]} {
diff --git a/mac/tkMacDefault.h b/mac/tkMacDefault.h
index fd55d68..64901d4 100644
--- a/mac/tkMacDefault.h
+++ b/mac/tkMacDefault.h
@@ -10,7 +10,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkMacDefault.h,v 1.15 2002/06/21 02:38:54 hobbs Exp $
+ * RCS: @(#) $Id: tkMacDefault.h,v 1.16 2002/06/21 23:09:55 hobbs Exp $
  */
 
 #ifndef _TKMACDEFAULT
@@ -486,6 +486,7 @@
 #define DEF_TEXT_INSERT_OFF_TIME	"300"
 #define DEF_TEXT_INSERT_ON_TIME		"600"
 #define DEF_TEXT_INSERT_WIDTH		"1"
+#define DEF_TEXT_MAX_UNDO    	"0"
 #define DEF_TEXT_PADX			"1"
 #define DEF_TEXT_PADY			"1"
 #define DEF_TEXT_RELIEF			"flat"
diff --git a/tests/text.test b/tests/text.test
index cddc199..c65c7fb 100644
--- a/tests/text.test
+++ b/tests/text.test
@@ -6,7 +6,7 @@
 # Copyright (c) 1998-1999 by Scriptics Corporation.
 # All rights reserved.
 #
-# RCS: @(#) $Id: text.test,v 1.14 2001/11/13 00:19:05 hobbs Exp $
+# RCS: @(#) $Id: text.test,v 1.15 2002/06/21 23:09:53 hobbs Exp $
 
 if {[lsearch [namespace children] ::tcltest] == -1} {
     source [file join [pwd] [file dirname [info script]] defs.tcl]
@@ -70,6 +70,7 @@ foreach test {
     {-insertofftime 100 100 2.4}
     {-insertontime 47 47 e1}
     {-insertwidth 2.3 2 47d}
+    {-maxundo 5 5 noway}
     {-padx 3.4 3 2.4.}
     {-pady 82 82 bogus}
     {-relief raised raised bumpy}
@@ -113,7 +114,7 @@ test text-1.[incr i] {text options} {
 	lappend result [lindex $i 4]
     }
     set result
-} {1 blue {} {} 7 watch 0 {} fixed #012 5 #123 #234 0 green 45 100 47 2 3 82 raised #ffff01234567 21 yellow 0 0 0 0 disabled {1i 2i 3i 4i} {any old thing} 1 73 word {x scroll command} {test command}}
+} {1 blue {} {} 7 watch 0 {} fixed #012 5 #123 #234 0 green 45 100 47 2 5 3 82 raised #ffff01234567 21 yellow 0 0 0 0 disabled {1i 2i 3i 4i} {any old thing} 1 73 word {x scroll command} {test command}}
 
 test text-2.1 {Tk_TextCmd procedure} {
     list [catch {text} msg] $msg
@@ -1481,6 +1482,19 @@ test text-25.12 {<<Selection>> virtual event} {
     set ::retval
 } {selection_changed}
 
+test text-25.13 {-maxundo configuration option} {
+    catch {destroy .t}
+    text .t -undo 1  -autoseparators 1 -maxundo 2
+    pack .t
+    .t insert end "line 1\n"
+    .t delete 1.4 1.6
+    .t insert end "line 2\n"
+    catch {.t edit undo}
+    catch {.t edit undo}
+    catch {.t edit undo}
+    .t get 1.0 end
+} "line 1\n\n"
+
 eval destroy [winfo child .]
 option clear
 
diff --git a/unix/Makefile.in b/unix/Makefile.in
index b48dc78..62f9bec 100644
--- a/unix/Makefile.in
+++ b/unix/Makefile.in
@@ -5,7 +5,7 @@
 # "autoconf" program (constructs like "@foo@" will get replaced in the
 # actual Makefile.
 #
-# RCS: @(#) $Id: Makefile.in,v 1.70 2002/06/21 20:24:29 dgp Exp $
+# RCS: @(#) $Id: Makefile.in,v 1.71 2002/06/21 23:09:53 hobbs Exp $
 
 # Current Tk version;  used in various names.
 
@@ -287,7 +287,7 @@ OBJS =  tk3d.o tkArgv.o tkAtom.o tkBind.o tkBitmap.o tkClipboard.o tkCmds.o \
 	tkColor.o tkConfig.o tkConsole.o tkCursor.o tkError.o tkEvent.o \
 	tkFocus.o tkFont.o tkGet.o tkGC.o tkGeometry.o tkGrab.o tkGrid.o \
 	tkMain.o tkObj.o tkOldConfig.o tkOption.o tkPack.o tkPlace.o \
-	tkSelect.o tkStyle.o tkUtil.o tkVisual.o tkWindow.o  \
+	tkSelect.o tkStyle.o tkUndo.o tkUtil.o tkVisual.o tkWindow.o  \
 	$(UNIXOBJS) $(WIDGOBJS) $(CANVOBJS) $(IMAGEOBJS) $(TEXTOBJS)
 
 TK_DECLS = \
@@ -308,8 +308,8 @@ SRCS = \
 	$(GENERIC_DIR)/tkMain.c $(GENERIC_DIR)/tkOption.c \
 	$(GENERIC_DIR)/tkPack.c $(GENERIC_DIR)/tkPlace.c \
 	$(GENERIC_DIR)/tkSelect.c $(GENERIC_DIR)/tkStyle.c \
-	$(GENERIC_DIR)/tkUtil.c $(GENERIC_DIR)/tkVisual.c \
-	$(GENERIC_DIR)/tkWindow.c \
+	$(GENERIC_DIR)/tkUndo.c $(GENERIC_DIR)/tkUtil.c \
+	$(GENERIC_DIR)/tkVisual.c $(GENERIC_DIR)/tkWindow.c \
 	$(GENERIC_DIR)/tkButton.c $(GENERIC_DIR)/tkObj.c \
 	$(GENERIC_DIR)/tkEntry.c $(GENERIC_DIR)/tkFrame.c \
 	$(GENERIC_DIR)/tkListbox.c $(GENERIC_DIR)/tkMenu.c \
@@ -879,6 +879,9 @@ tkStubLib.o: $(GENERIC_DIR)/tkStubLib.c
 tkStubImg.o: $(GENERIC_DIR)/tkStubImg.c
 	$(CC) -c $(CC_SWITCHES) $(GENERIC_DIR)/tkStubImg.c
 
+tkUndo.o: $(GENERIC_DIR)/tkUndo.c
+	$(CC) -c $(CC_SWITCHES) $(GENERIC_DIR)/tkUndo.c
+
 tkUnix.o: $(UNIX_DIR)/tkUnix.c
 	$(CC) -c $(CC_SWITCHES) $(UNIX_DIR)/tkUnix.c
 
diff --git a/unix/tkUnixDefault.h b/unix/tkUnixDefault.h
index d0afe39..f8af12d 100644
--- a/unix/tkUnixDefault.h
+++ b/unix/tkUnixDefault.h
@@ -10,7 +10,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkUnixDefault.h,v 1.15 2002/06/21 02:38:54 hobbs Exp $
+ * RCS: @(#) $Id: tkUnixDefault.h,v 1.16 2002/06/21 23:09:54 hobbs Exp $
  */
 
 #ifndef _TKUNIXDEFAULT
@@ -476,6 +476,7 @@
 #define DEF_TEXT_INSERT_OFF_TIME	"300"
 #define DEF_TEXT_INSERT_ON_TIME		"600"
 #define DEF_TEXT_INSERT_WIDTH		"2"
+#define DEF_TEXT_MAX_UNDO    	"0"
 #define DEF_TEXT_PADX			"1"
 #define DEF_TEXT_PADY			"1"
 #define DEF_TEXT_RELIEF			"sunken"
diff --git a/win/Makefile.in b/win/Makefile.in
index f3a9c33..5e1fdfc 100644
--- a/win/Makefile.in
+++ b/win/Makefile.in
@@ -4,7 +4,7 @@
 # "autoconf" program (constructs like "@foo@" will get replaced in the
 # actual Makefile.
 #
-# RCS: @(#) $Id: Makefile.in,v 1.51 2002/06/18 23:51:46 dkf Exp $
+# RCS: @(#) $Id: Makefile.in,v 1.52 2002/06/21 23:09:54 hobbs Exp $
 
 TCLVERSION		= @TCL_VERSION@
 VERSION			= @TK_VERSION@
@@ -340,6 +340,7 @@ TK_OBJS = \
 	tkTextTag.$(OBJEXT) \
 	tkTextWind.$(OBJEXT) \
 	tkTrig.$(OBJEXT) \
+	tkUndo.$(OBJEXT) \
 	tkUtil.$(OBJEXT) \
 	tkVisual.$(OBJEXT) \
 	tkStubInit.$(OBJEXT) \
diff --git a/win/makefile.vc b/win/makefile.vc
index 834b4c7..efa2b81 100644
--- a/win/makefile.vc
+++ b/win/makefile.vc
@@ -12,7 +12,7 @@
 # Copyright (c) 2001-2002 David Gravereaux.
 #
 #------------------------------------------------------------------------------
-# RCS: @(#) $Id: makefile.vc,v 1.61 2002/06/18 23:51:46 dkf Exp $
+# RCS: @(#) $Id: makefile.vc,v 1.62 2002/06/21 23:09:54 hobbs Exp $
 #------------------------------------------------------------------------------
 
 !if "$(MSVCDIR)" == ""
@@ -361,6 +361,7 @@ TKOBJS = \
 	$(TMP_DIR)\tkTextTag.obj \
 	$(TMP_DIR)\tkTextWind.obj \
 	$(TMP_DIR)\tkTrig.obj \
+	$(TMP_DIR)\tkUndo.obj \
 	$(TMP_DIR)\tkUtil.obj \
 	$(TMP_DIR)\tkVisual.obj \
 	$(TMP_DIR)\tkStubInit.obj \
@@ -758,6 +759,7 @@ $(GENERICDIR)/tkScrollbar.c: $(GENERICDIR)/default.h
 $(GENERICDIR)/tkText.c: $(GENERICDIR)/default.h
 $(GENERICDIR)/tkTextIndex.c: $(GENERICDIR)/default.h
 $(GENERICDIR)/tkTextTag.c: $(GENERICDIR)/default.h
+$(GENERICDIR)/tkUndo.c: $(GENERICDIR)/tkUndo.h
 
 $(GENERICDIR)/tkText.c: $(GENERICDIR)/tkText.h
 $(GENERICDIR)/tkTextBTree.c: $(GENERICDIR)/tkText.h
diff --git a/win/tkWinDefault.h b/win/tkWinDefault.h
index e9f999b..66c1ae4 100644
--- a/win/tkWinDefault.h
+++ b/win/tkWinDefault.h
@@ -9,7 +9,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkWinDefault.h,v 1.15 2002/06/21 02:38:54 hobbs Exp $
+ * RCS: @(#) $Id: tkWinDefault.h,v 1.16 2002/06/21 23:09:54 hobbs Exp $
  */
 
 #ifndef _TKWINDEFAULT
@@ -481,6 +481,7 @@
 #define DEF_TEXT_INSERT_OFF_TIME	"300"
 #define DEF_TEXT_INSERT_ON_TIME		"600"
 #define DEF_TEXT_INSERT_WIDTH		"2"
+#define DEF_TEXT_MAX_UNDO    	"0"
 #define DEF_TEXT_PADX			"1"
 #define DEF_TEXT_PADY			"1"
 #define DEF_TEXT_RELIEF			"sunken"