diff -c -P -r ../tk8.4a4/doc/text.n ./doc/text.n
*** ../tk8.4a4/doc/text.n	Thu Nov 15 22:27:54 2001
--- ./doc/text.n	Sat May 11 06:54:37 2002
***************
*** 732,738 ****
  .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.
  .PP
  Boundaries (called "separators") are inserted between edit actions.
  The purpose of these separators is to group inserts and deletes into
--- 732,738 ----
  .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 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,758 ****
  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
  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
  does not work when the modified flag has been set by the user, until
  the flag has been reset again.
  .PP
--- 746,758 ----
  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 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
! 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 -c -P -r ../tk8.4a4/generic/tkText.c ./generic/tkText.c
*** ../tk8.4a4/generic/tkText.c	Tue Feb 26 02:58:25 2002
--- ./generic/tkText.c	Sat May 11 07:02:08 2002
***************
*** 20,25 ****
--- 20,26 ----
  #include "default.h"
  #include "tkPort.h"
  #include "tkInt.h"
+ #include "tkUndo.h"
  
  #ifdef MAC_TCL
  #define Style TkStyle
***************
*** 317,328 ****
  			    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));
  
  /*
--- 318,323 ----
***************
*** 415,420 ****
--- 410,416 ----
      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,818 ****
      if (textPtr->bindingTable != NULL) {
  	Tk_DeleteBindingTable(textPtr->bindingTable);
      }
!     clearStack(&(textPtr->undoStack));
!     clearStack(&(textPtr->redoStack));
  
      /*
       * NOTE: do NOT free up selBorder, selBdString, or selFgColorPtr:
--- 807,814 ----
      if (textPtr->bindingTable != NULL) {
  	Tk_DeleteBindingTable(textPtr->bindingTable);
      }
!     TkUndoClearStack(&(textPtr->undoStack));
!     TkUndoClearStack(&(textPtr->redoStack));
  
      /*
       * NOTE: do NOT free up selBorder, selBdString, or selFgColorPtr:
***************
*** 1193,1199 ****
  {
      int lineIndex, resetView, offset;
      TkTextIndex newTop;
-     TkTextEditAtom * insertion;
      char indexBuffer[TK_POS_CHARS];
  
      /*
--- 1189,1194 ----
***************
*** 1229,1251 ****
       */
  
      if ( textPtr->undo ) {
!         if (textPtr->autoSeparators && textPtr->undoStack &&
!             textPtr->undoStack->type != TK_EDIT_INSERT) {
!             insertSeparator(&(textPtr->undoStack));
          }
          
!         insertion = (TkTextEditAtom *) ckalloc(sizeof(TkTextEditAtom));
!         insertion->type = TK_EDIT_INSERT;
          
          TkTextPrintIndex(indexPtr,indexBuffer);
!         insertion->index = (char *) ckalloc(strlen(indexBuffer) + 1);
!         strcpy(insertion->index,indexBuffer);
          
!         insertion->string = (char *) ckalloc(strlen(string) + 1);
!         strcpy(insertion->string,string);
  
-         pushStack(&(textPtr->undoStack),insertion);
-         clearStack(&(textPtr->redoStack));
      }
      updateDirtyFlag(textPtr);
  
--- 1224,1283 ----
       */
  
      if ( textPtr->undo ) {
!         TkTextIndex     toIndex;
! 
!         Tcl_DString actionCommand;
!         Tcl_DString revertCommand;
!         
!         if (textPtr->autoSeparators &&
!             textPtr->lastEditMode != TK_TEXT_EDIT_INSERT) {
!             TkUndoInsertSeparator(&(textPtr->undoStack));
          }
          
!         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);
!         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);
          
+         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);
!         TkUndoClearStack(&(textPtr->redoStack));
! 
!      	Tcl_DStringFree(&actionCommand);
!      	Tcl_DStringFree(&revertCommand);
  
      }
      updateDirtyFlag(textPtr);
  
***************
*** 1292,1298 ****
  {
      int line1, line2, line, byteIndex, resetView;
      TkTextIndex index1, index2;
-     TkTextEditAtom * deletion;
      char indexBuffer[TK_POS_CHARS];
  
      /*
--- 1324,1329 ----
***************
*** 1412,1438 ****
  
      if (textPtr->undo) {
  	Tcl_DString ds;
  
! 	if (textPtr->autoSeparators && (textPtr->undoStack != NULL)
! 		&& (textPtr->undoStack->type != TK_EDIT_DELETE)) {
! 	   insertSeparator(&(textPtr->undoStack));
! 	}
  
! 	deletion = (TkTextEditAtom *) ckalloc(sizeof(TkTextEditAtom));
! 	deletion->type = TK_EDIT_DELETE;
  
! 	TkTextPrintIndex(&index1, indexBuffer);
! 	deletion->index = (char *) ckalloc(strlen(indexBuffer) + 1);
! 	strcpy(deletion->index, indexBuffer);
  
! 	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));
      }
      updateDirtyFlag(textPtr);
  
--- 1443,1501 ----
  
      if (textPtr->undo) {
  	Tcl_DString ds;
+         Tcl_DString actionCommand;
+         Tcl_DString revertCommand;
+     
+ 	if (textPtr->autoSeparators
+ 		&& (textPtr->lastEditMode != TK_TEXT_EDIT_DELETE)) {
+ 	   TkUndoInsertSeparator(&(textPtr->undoStack));
+ 	}
+ 
+ 	textPtr->lastEditMode = TK_TEXT_EDIT_DELETE;
+ 
+         Tcl_DStringInit(&actionCommand);
+         Tcl_DStringInit(&revertCommand);
+ 
+         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);
  
!         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);
! 	TkUndoClearStack(&(textPtr->redoStack));
  
!         Tcl_DStringFree(&actionCommand);
!         Tcl_DStringFree(&revertCommand);
  
      }
      updateDirtyFlag(textPtr);
  
***************
*** 2483,2580 ****
  }
  
  /*
-  * 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.
   *
--- 2546,2551 ----
***************
*** 2589,2598 ****
      Tcl_Interp * interp;
      TkText     * textPtr;          /* Overall information about text widget. */
  {
!     TkTextEditAtom * elem;
!     TkTextIndex      fromIndex, toIndex;
!     char             buffer[TK_POS_CHARS];
!     char             viewIndex[TK_POS_CHARS];
      
      if ( ! textPtr->undo ) {
         return TCL_OK;
--- 2560,2566 ----
      Tcl_Interp * interp;
      TkText     * textPtr;          /* Overall information about text widget. */
  {
!     TkUndoAtom * elem;
      
      if ( ! textPtr->undo ) {
         return TCL_OK;
***************
*** 2604,2659 ****
  
      /* insert a separator on the redo stack */
  
!     insertSeparator(&(textPtr->redoStack));
  
      /* 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 */
      
--- 2572,2603 ----
  
      /* insert a separator on the redo stack */
  
!     TkUndoInsertSeparator(&(textPtr->redoStack));
  
      /* Pop and skip the first separator if there is one*/
  
!     elem = TkUndoPopStack(&(textPtr->undoStack));
  
      if ( elem == NULL ) {
          textPtr->undo = 1;
          return TCL_ERROR;
      }
  
!     if ( ( elem != NULL ) && ( elem->type == TK_UNDO_SEPARATOR ) ) {
          ckfree((char *) elem);
!         elem = TkUndoPopStack(&(textPtr->undoStack));
      }
      
!     while ( elem && (elem->type != TK_UNDO_SEPARATOR) ) {
!         Tcl_EvalObjEx(interp,elem->revert,TCL_EVAL_GLOBAL);
!         
!         TkUndoPushStack(&(textPtr->redoStack),elem);
!         elem = TkUndoPopStack(&(textPtr->undoStack));
      }
      
      /* insert a separator on the undo stack */
      
!     TkUndoInsertSeparator(&(textPtr->undoStack));
      
      /* Turn back on the undo feature */
      
***************
*** 2677,2686 ****
      Tcl_Interp * interp;
      TkText     * textPtr;       /* Overall information about text widget. */
  {
!     TkTextEditAtom *elem;
!     TkTextIndex     fromIndex, toIndex;
!     char            buffer[TK_POS_CHARS];
!     char            viewIndex[TK_POS_CHARS];
  
      if (!textPtr->undo) {
         return TCL_OK;
--- 2621,2627 ----
      Tcl_Interp * interp;
      TkText     * textPtr;       /* Overall information about text widget. */
  {
!     TkUndoAtom *elem;
  
      if (!textPtr->undo) {
         return TCL_OK;
***************
*** 2692,2745 ****
  
      /* 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 */
- 
-     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 */
      
--- 2633,2664 ----
  
      /* insert a separator on the undo stack */
  
!     TkUndoInsertSeparator(&(textPtr->undoStack));
  
      /* Pop and skip the first separator if there is one*/
  
!     elem = TkUndoPopStack(&(textPtr->redoStack));
  
      if ( elem == NULL ) {
         textPtr->undo = 1;
         return TCL_ERROR;
      }
  
!     if ( ( elem != NULL ) && ( elem->type == TK_UNDO_SEPARATOR ) ) {
          ckfree((char *) elem);
!         elem = TkUndoPopStack(&(textPtr->redoStack));
      }
  
!     while ( elem && (elem->type != TK_UNDO_SEPARATOR) ) {
!         Tcl_EvalObjEx(interp,elem->action,TCL_EVAL_GLOBAL);
!         
!         TkUndoPushStack(&(textPtr->undoStack), elem);
!         elem = TkUndoPopStack(&(textPtr->redoStack));
      }
  
      /* insert a separator on the undo stack */
      
!     TkUndoInsertSeparator(&(textPtr->undoStack));
  
      /* Turn back on the undo feature */
      
***************
*** 2834,2848 ****
  		    argv[0], " edit reset\"", (char *) NULL);
  	    return TCL_ERROR;
  	}
!         clearStack(&(textPtr->undoStack));
!         clearStack(&(textPtr->redoStack));
      } 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));
      } else if ((c == 'u') && (strncmp(argv[2], "undo", length) == 0)) {
  	if (argc != 3) {
  	    Tcl_AppendResult(interp, "wrong # args: should be \"",
--- 2753,2767 ----
  		    argv[0], " edit reset\"", (char *) NULL);
  	    return TCL_ERROR;
  	}
!         TkUndoClearStack(&(textPtr->undoStack));
!         TkUndoClearStack(&(textPtr->redoStack));
      } 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;
  	}
!         TkUndoInsertSeparator(&(textPtr->undoStack));
      } else if ((c == 'u') && (strncmp(argv[2], "undo", length) == 0)) {
  	if (argc != 3) {
  	    Tcl_AppendResult(interp, "wrong # args: should be \"",
diff -c -P -r ../tk8.4a4/generic/tkText.h ./generic/tkText.h
*** ../tk8.4a4/generic/tkText.h	Sat Jan 26 01:41:28 2002
--- ./generic/tkText.h	Fri May 10 16:24:17 2002
***************
*** 20,25 ****
--- 20,29 ----
  #include "tk.h"
  #endif
  
+ #ifndef _TKUNDO
+ #include "tkUndo.h"
+ #endif
+ 
  #ifdef BUILD_tk
  # undef TCL_STORAGE_CLASS
  # define TCL_STORAGE_CLASS DLLEXPORT
***************
*** 451,474 ****
  					 * BE THE LAST IN THE STRUCTURE. */
  } TkTextTabArray;
  
! /* enum definining the types used in an edit stack */
  
  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;
  
  /*
   * A data structure of the following type is kept for each text widget that
--- 455,467 ----
  					 * BE THE LAST IN THE STRUCTURE. */
  } TkTextTabArray;
  
! /* enum definining the edit modes of */
  
  typedef enum {
!     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,657 ****
       * Information related to the undo/redo functonality
       */
       
!     TkTextEditAtom * undoStack; /* The undo stack */
      
!     TkTextEditAtom * redoStack; /* The redo stack */
      
      int undo;			/* non zero means the undo/redo behaviour is 
  				 * enabled */
--- 642,650 ----
       * Information related to the undo/redo functonality
       */
       
!     TkUndoAtom * undoStack; /* The undo stack */
      
!     TkUndoAtom * redoStack; /* The redo stack */
      
      int undo;			/* non zero means the undo/redo behaviour is 
  				 * enabled */
***************
*** 672,677 ****
--- 665,673 ----
  				 * incremented every edit action
  				 */
  
+     TkTextEditMode lastEditMode;	/* Keeps track of what the last edit mode was
+ 				 */
+ 
  } TkText;
  
  /*
diff -c -P -r ../tk8.4a4/generic/tkUndo.c ./generic/tkUndo.c
*** ../tk8.4a4/generic/tkUndo.c	Thu Jan  1 01:00:00 1970
--- ./generic/tkUndo.c	Sat May 11 06:59:24 2002
***************
*** 0 ****
--- 1,138 ----
+ /* 
+  * 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.26 2002/02/26 01:58:25 lgac 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.
+  */
+  
+ void 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);
+     }
+ }
+ 
+ /*
+  * 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->action);
+             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 )
+     TkUndoAtom ** 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_COMMAND;
+ 
+     atom->action = Tcl_NewStringObj(Tcl_DStringValue(actionScript),Tcl_DStringLength(actionScript));
+     Tcl_IncrRefCount(atom->action);
+ 
+     atom->revert = Tcl_NewStringObj(Tcl_DStringValue(revertScript),Tcl_DStringLength(revertScript));
+     Tcl_IncrRefCount(atom->revert);
+ 
+ 	TkUndoPushStack(stack, atom);
+ }
diff -c -P -r ../tk8.4a4/generic/tkUndo.h ./generic/tkUndo.h
*** ../tk8.4a4/generic/tkUndo.h	Thu Jan  1 01:00:00 1970
--- ./generic/tkUndo.h	Fri May 10 17:32:01 2002
***************
*** 0 ****
--- 1,52 ----
+ /*
+  * 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.10 2002/01/25 21:09:37 lgac Exp $
+  */
+ 
+ #ifndef _TKUNDO
+ #define _TKUNDO
+ 
+ #ifndef _TK
+ #include "tk.h"
+ #endif
+ 
+ /* enum definining the types used in an undo stack */
+ 
+ typedef enum {
+     TK_UNDO_SEPARATOR,			/* Marker */
+     TK_UNDO_COMMAND			/* 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 * action;			/* 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;
+ 
+ EXTERN void TkUndoPushStack  _ANSI_ARGS_((TkUndoAtom ** stack,
+     TkUndoAtom *  elem));
+ 
+ EXTERN TkUndoAtom * TkUndoPopStack _ANSI_ARGS_((TkUndoAtom ** stack));
+  
+ EXTERN void TkUndoInsertSeparator _ANSI_ARGS_((TkUndoAtom ** stack));
+ 
+ EXTERN void TkUndoClearStack _ANSI_ARGS_((TkUndoAtom ** stack));
+ 
+ EXTERN void TkUndoPushAction _ANSI_ARGS_((TkUndoAtom ** stack,
+     Tcl_DString * actionScript, Tcl_DString * revertScript));
+ 
+ #endif /* _TKUNDO */
diff -c -P -r ../tk8.4a4/library/text.tcl ./library/text.tcl
*** ../tk8.4a4/library/text.tcl	Tue Feb 19 01:01:35 2002
--- ./library/text.tcl	Sat May 11 06:49:02 2002
***************
*** 339,353 ****
  }
  
  bind Text <<Undo>> {
!     if { ! [ catch { %W edit undo } ] } {
!        %W see insert
!     }
  }
  
  bind Text <<Redo>> {
!     if { ! [ catch { %W edit redo } ] } {
!        %W see insert
!     }
  }
  
  if {[string compare $tcl_platform(platform) "windows"]} {
--- 339,349 ----
  }
  
  bind Text <<Undo>> {
!     catch { %W edit undo }
  }
  
  bind Text <<Redo>> {
!     catch { %W edit redo }
  }
  
  if {[string compare $tcl_platform(platform) "windows"]} {
***************
*** 635,641 ****
  
  proc ::tk::TextPaste {w x y} {
      $w mark set insert [TextClosestGap $w $x $y]
-     catch {$w insert insert [::tk::GetSelection $w PRIMARY]}
      catch {
  	set oldSeparator [$w cget -autoseparators]
  	if {$oldSeparator} {
--- 631,636 ----
diff -c -P -r ../tk8.4a4/unix/Makefile.in ./unix/Makefile.in
*** ../tk8.4a4/unix/Makefile.in	Wed Mar  6 09:51:50 2002
--- ./unix/Makefile.in	Sat May 11 07:09:35 2002
***************
*** 277,282 ****
--- 277,284 ----
  TEXTOBJS = tkText.o tkTextBTree.o tkTextDisp.o tkTextImage.o tkTextIndex.o \
  	tkTextMark.o tkTextTag.o tkTextWind.o
  
+ UNDOOBJS = tkUndo.o
+ 
  UNIXOBJS = tkUnix.o tkUnix3d.o tkUnixButton.o tkUnixColor.o tkUnixConfig.o \
  	tkUnixCursor.o tkUnixDraw.o tkUnixEmbed.o tkUnixEvent.o \
  	tkUnixFocus.o tkUnixFont.o tkUnixInit.o tkUnixKey.o tkUnixMenu.o \
***************
*** 290,296 ****
  	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 tkUtil.o tkVisual.o tkWindow.o  \
! 	$(UNIXOBJS) $(WIDGOBJS) $(CANVOBJS) $(IMAGEOBJS) $(TEXTOBJS)
  
  TK_DECLS = \
  	$(GENERIC_DIR)/tk.decls \
--- 292,298 ----
  	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 tkUtil.o tkVisual.o tkWindow.o  \
! 	$(UNIXOBJS) $(WIDGOBJS) $(CANVOBJS) $(IMAGEOBJS) $(TEXTOBJS) $(UNDOOBJS)
  
  TK_DECLS = \
  	$(GENERIC_DIR)/tk.decls \
***************
*** 335,340 ****
--- 337,343 ----
  	$(GENERIC_DIR)/tkOldConfig.c \
  	$(GENERIC_DIR)/tkSquare.c $(GENERIC_DIR)/tkTest.c \
  	$(GENERIC_DIR)/tkStubInit.c $(GENERIC_DIR)/tkStubLib.c \
+ 	$(GENERIC_DIR)/tkUndo.c \
  	$(UNIX_DIR)/tkAppInit.c $(UNIX_DIR)/tkUnix.c \
  	$(UNIX_DIR)/tkUnix3d.c \
  	$(UNIX_DIR)/tkUnixButton.c $(UNIX_DIR)/tkUnixColor.c \
***************
*** 884,889 ****
--- 887,895 ----
  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 -c -P -r ../tk8.4a4/win/Makefile.in ./win/Makefile.in
*** ../tk8.4a4/win/Makefile.in	Wed Mar  6 09:51:52 2002
--- ./win/Makefile.in	Sat May 11 07:04:39 2002
***************
*** 339,344 ****
--- 339,345 ----
  	tkTextTag.$(OBJEXT) \
  	tkTextWind.$(OBJEXT) \
  	tkTrig.$(OBJEXT) \
+ 	tkUndo.$(OBJEXT) \
  	tkUtil.$(OBJEXT) \
  	tkVisual.$(OBJEXT) \
  	tkStubInit.$(OBJEXT) \
