Overview
| Artifact ID: | 8e2ab5e4b007d760e59f077752d0ea559e4ae3c0 |
|---|---|
| Ticket: | 554763ffffffffffffffffffffffffffffffffff |
| Date: | 2002-06-22 06:04:22 |
| User: | hobbs |
| Artifact Attached: | dcf19ff381a27e31b09a75269c1ad3dcaf5e576d |
| Filename: | tip104_hobbs.txt |
| Description: | actual patch applied, based on patch4 |
Content:
? generic/tkCanvText.c.rot ? generic/tkPanedWindow.c.cur ? generic/tkImgGIF.c.trans ? doc/man.macros Index: tests/text.test =================================================================== RCS file: /cvsroot/tktoolkit/tk/tests/text.test,v retrieving revision 1.14 diff -b -u -r1.14 text.test --- tests/text.test 13 Nov 2001 00:19:05 -0000 1.14 +++ tests/text.test 21 Jun 2002 23:00:33 -0000 @@ -70,6 +70,7 @@ {-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 @@ 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 @@ -1480,6 +1481,19 @@ .t tag add sel 1.0 1.1 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 Index: unix/Makefile.in =================================================================== RCS file: /cvsroot/tktoolkit/tk/unix/Makefile.in,v retrieving revision 1.70 diff -b -u -r1.70 Makefile.in --- unix/Makefile.in 21 Jun 2002 20:24:29 -0000 1.70 +++ unix/Makefile.in 21 Jun 2002 23:00:33 -0000 @@ -287,7 +287,7 @@ 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 @@ $(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 \ @@ -878,6 +878,9 @@ 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 Index: unix/tkUnixDefault.h =================================================================== RCS file: /cvsroot/tktoolkit/tk/unix/tkUnixDefault.h,v retrieving revision 1.15 diff -b -u -r1.15 tkUnixDefault.h --- unix/tkUnixDefault.h 21 Jun 2002 02:38:54 -0000 1.15 +++ unix/tkUnixDefault.h 21 Jun 2002 23:00:33 -0000 @@ -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" Index: win/Makefile.in =================================================================== RCS file: /cvsroot/tktoolkit/tk/win/Makefile.in,v retrieving revision 1.51 diff -b -u -r1.51 Makefile.in --- win/Makefile.in 18 Jun 2002 23:51:46 -0000 1.51 +++ win/Makefile.in 21 Jun 2002 23:00:33 -0000 @@ -340,6 +340,7 @@ tkTextTag.$(OBJEXT) \ tkTextWind.$(OBJEXT) \ tkTrig.$(OBJEXT) \ + tkUndo.$(OBJEXT) \ tkUtil.$(OBJEXT) \ tkVisual.$(OBJEXT) \ tkStubInit.$(OBJEXT) \ Index: win/tkWinDefault.h =================================================================== RCS file: /cvsroot/tktoolkit/tk/win/tkWinDefault.h,v retrieving revision 1.15 diff -b -u -r1.15 tkWinDefault.h --- win/tkWinDefault.h 21 Jun 2002 02:38:54 -0000 1.15 +++ win/tkWinDefault.h 21 Jun 2002 23:00:33 -0000 @@ -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" Index: generic/tkText.c =================================================================== RCS file: /cvsroot/tktoolkit/tk/generic/tkText.c,v retrieving revision 1.26 diff -b -u -r1.26 tkText.c --- generic/tkText.c 26 Feb 2002 01:58:25 -0000 1.26 +++ generic/tkText.c 21 Jun 2002 23:00:33 -0000 @@ -20,6 +20,7 @@ #include "default.h" #include "tkPort.h" #include "tkInt.h" +#include "tkUndo.h" #ifdef MAC_TCL #define Style TkStyle @@ -90,6 +91,8 @@ 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 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 @@ 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 @@ 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 @@ 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 @@ { int lineIndex, resetView, offset; TkTextIndex newTop; - TkTextEditAtom * insertion; char indexBuffer[TK_POS_CHARS]; /* @@ -1229,23 +1226,59 @@ */ 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); + 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); - insertion->index = (char *) ckalloc(strlen(indexBuffer) + 1); - strcpy(insertion->index,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); - insertion->string = (char *) ckalloc(strlen(string) + 1); - strcpy(insertion->string,string); + TkUndoPushAction(textPtr->undoStack,&actionCommand, &revertCommand); + + Tcl_DStringFree(&actionCommand); + Tcl_DStringFree(&revertCommand); - pushStack(&(textPtr->undoStack),insertion); - clearStack(&(textPtr->redoStack)); } updateDirtyFlag(textPtr); @@ -1292,7 +1325,6 @@ { int line1, line2, line, byteIndex, resetView; TkTextIndex index1, index2; - TkTextEditAtom * deletion; char indexBuffer[TK_POS_CHARS]; /* @@ -1412,27 +1444,58 @@ if (textPtr->undo) { Tcl_DString ds; + Tcl_DString actionCommand; + Tcl_DString revertCommand; - if (textPtr->autoSeparators && (textPtr->undoStack != NULL) - && (textPtr->undoStack->type != TK_EDIT_DELETE)) { - insertSeparator(&(textPtr->undoStack)); - } + if (textPtr->autoSeparators + && (textPtr->lastEditMode != TK_TEXT_EDIT_DELETE)) { + TkUndoInsertUndoSeparator(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); - deletion = (TkTextEditAtom *) ckalloc(sizeof(TkTextEditAtom)); - deletion->type = TK_EDIT_DELETE; + TextGetText(&index1, &index2, &ds); - TkTextPrintIndex(&index1, indexBuffer); - deletion->index = (char *) ckalloc(strlen(indexBuffer) + 1); - strcpy(deletion->index, indexBuffer); + 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); - TextGetText(&index1, &index2, &ds); - deletion->string = - (char *) ckalloc((unsigned int) Tcl_DStringLength(&ds) + 1); - strcpy(deletion->string, Tcl_DStringValue(&ds)); - Tcl_DStringFree(&ds); + TkUndoPushAction(textPtr->undoStack,&actionCommand, &revertCommand); + + Tcl_DStringFree(&actionCommand); + Tcl_DStringFree(&revertCommand); - pushStack(&(textPtr->undoStack), deletion); - clearStack(&(textPtr->redoStack)); } updateDirtyFlag(textPtr); @@ -2483,98 +2546,6 @@ } /* - * 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 @@ * 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 @@ textPtr->undo = 0; - /* insert a separator on the redo stack */ - - insertSeparator(&(textPtr->redoStack)); + /* revert one compound action */ - /* 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)); + status = TkUndoRevert(textPtr->undoStack); /* Turn back on the undo feature */ textPtr->undo = 1; - return TCL_OK; + return status; } /* @@ -2673,14 +2591,10 @@ * 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 @@ textPtr->undo = 0; - /* insert a separator on the undo stack */ - - insertSeparator(&(textPtr->undoStack)); + /* reapply one compound action */ - /* 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)); + status = TkUndoApply(textPtr->undoStack); /* Turn back on the undo feature */ textPtr->undo = 1; - return TCL_OK; + return status; } /* @@ -2823,7 +2690,7 @@ 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 @@ 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; Index: generic/tkText.h =================================================================== RCS file: /cvsroot/tktoolkit/tk/generic/tkText.h,v retrieving revision 1.10 diff -b -u -r1.10 tkText.h --- generic/tkText.h 25 Jan 2002 21:09:37 -0000 1.10 +++ generic/tkText.h 21 Jun 2002 23:00:33 -0000 @@ -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 @@ * 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 @@ * 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 */ @@ -670,6 +664,9 @@ int isDirtyIncrement; /* Amount with which the isDirty flag is * incremented every edit action + */ + + TkTextEditMode lastEditMode; /* Keeps track of what the last edit mode was */ } TkText; Index: generic/tkUndo.c =================================================================== RCS file: generic/tkUndo.c diff -N generic/tkUndo.c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ generic/tkUndo.c 21 Jun 2002 23:00:33 -0000 @@ -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.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. + */ + +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; +} + Index: generic/tkUndo.h =================================================================== RCS file: generic/tkUndo.h diff -N generic/tkUndo.h --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ generic/tkUndo.h 21 Jun 2002 23:00:33 -0000 @@ -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.10 2002/01/25 21:09:37 lgac 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 */ Index: doc/text.n =================================================================== RCS file: /cvsroot/tktoolkit/tk/doc/text.n,v retrieving revision 1.11 diff -b -u -r1.11 text.n --- doc/text.n 15 Nov 2001 11:55:26 -0000 1.11 +++ doc/text.n 21 Jun 2002 23:00:33 -0000 @@ -32,7 +32,7 @@ \-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 @@ 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 @@ .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 @@ 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 Index: library/text.tcl =================================================================== RCS file: /cvsroot/tktoolkit/tk/library/text.tcl,v retrieving revision 1.22 diff -b -u -r1.22 text.tcl --- library/text.tcl 7 Mar 2002 11:49:49 -0000 1.22 +++ library/text.tcl 21 Jun 2002 23:00:33 -0000 @@ -339,15 +339,11 @@ } 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"]} { Index: mac/tkMacDefault.h =================================================================== RCS file: /cvsroot/tktoolkit/tk/mac/tkMacDefault.h,v retrieving revision 1.15 diff -b -u -r1.15 tkMacDefault.h --- mac/tkMacDefault.h 21 Jun 2002 02:38:54 -0000 1.15 +++ mac/tkMacDefault.h 21 Jun 2002 23:00:33 -0000 @@ -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"