Overview
| Artifact ID: | 5299aa45bac28b44d5ca434e99272fd55991b9b0 |
|---|---|
| Ticket: | 554763ffffffffffffffffffffffffffffffffff |
| Date: | 2002-05-24 04:13:12 |
| User: | lgac |
| Artifact Attached: | 3aa0a9ed8b9a902751fba63a5add31737c464750 |
| Filename: | tk8.4a4_patch2.txt |
| Description: | Even more generalized undo |
Content:
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 11:42:20 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 18 09:10:27 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 ---- *************** *** 412,420 **** --- 407,417 ---- TkTextSetYView(textPtr, &startIndex, 0); textPtr->exportSelection = 1; textPtr->pickEvent.type = LeaveNotify; + textPtr->undoStack = TkUndoInitStack(); 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: --- 808,814 ---- if (textPtr->bindingTable != NULL) { Tk_DeleteBindingTable(textPtr->bindingTable); } ! TkUndoFreeStack(textPtr->undoStack); /* * 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,1282 ---- */ if ( textPtr->undo ) { ! TkTextIndex toIndex; ! ! Tcl_DString actionCommand; ! Tcl_DString revertCommand; ! ! if (textPtr->autoSeparators && ! textPtr->lastEditMode != TK_TEXT_EDIT_INSERT) { ! TkUndoInsertUndoSeparator(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); ! ! 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]; /* --- 1323,1328 ---- *************** *** 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); --- 1442,1499 ---- if (textPtr->undo) { Tcl_DString ds; + Tcl_DString actionCommand; + Tcl_DString revertCommand; + + 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); ! 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); ! 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. * --- 2544,2549 ---- *************** *** 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; --- 2558,2564 ---- Tcl_Interp * interp; TkText * textPtr; /* Overall information about text widget. */ { ! int status; if ( ! textPtr->undo ) { return TCL_OK; *************** *** 2602,2665 **** textPtr->undo = 0; ! /* 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 */ textPtr->undo = 1; ! return TCL_OK; } /* --- 2568,2582 ---- textPtr->undo = 0; ! /* revert one compound action */ ! status = TkUndoRevert(textPtr->undoStack,interp); /* Turn back on the undo feature */ textPtr->undo = 1; ! return status; } /* *************** *** 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; --- 2594,2600 ---- Tcl_Interp * interp; TkText * textPtr; /* Overall information about text widget. */ { ! int status; if (!textPtr->undo) { return TCL_OK; *************** *** 2690,2751 **** 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 */ ! ! 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; } /* --- 2604,2618 ---- textPtr->undo = 0; ! /* reapply one compound action */ ! status = TkUndoApply(textPtr->undoStack,interp); /* Turn back on the undo feature */ textPtr->undo = 1; ! return status; } /* *************** *** 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 \"", --- 2701,2714 ---- argv[0], " edit reset\"", (char *) NULL); return TCL_ERROR; } ! 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; } ! TkUndoInsertUndoSeparator(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 Sat May 18 07:12:57 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,648 ---- * Information related to the undo/redo functonality */ ! TkUndoRedoStack * undoStack; /* The undo/redo stack */ int undo; /* non zero means the undo/redo behaviour is * enabled */ *************** *** 672,677 **** --- 663,671 ---- * 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 18 09:08:10 2002 *************** *** 0 **** --- 1,317 ---- + /* + * 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->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_COMMAND; + + 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 ( ) + { + TkUndoRedoStack * stack; /* An Undo/Redo stack */ + stack = (TkUndoRedoStack *) ckalloc(sizeof(TkUndoRedoStack)); + stack->undoStack = NULL; + stack->redoStack = NULL; + return stack; + } + + + /* + * 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)); + } + + + /* + * 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); + } + + + /* + * 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; + { + TkUndoInsertSeparator(&(stack->undoStack)); + } + + + /* + * TkUndoRevert -- + * Undo a compound action on the stack. + * + * Results: + * A TCL status code + * + * Side effects: + * None. + */ + + int TkUndoRevert ( stack, interp ) + TkUndoRedoStack * stack; + Tcl_Interp * interp; + { + TkUndoAtom * elem; + + /* insert a separator on the redo 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(interp,elem->revert,TCL_EVAL_GLOBAL); + + TkUndoPushStack(&(stack->redoStack),elem); + elem = TkUndoPopStack(&(stack->undoStack)); + } + + /* insert a separator on the undo stack */ + + TkUndoInsertSeparator(&(stack->undoStack)); + + return TCL_OK; + } + + + /* + * TkUndoApply -- + * Redo a compound action on the stack. + * + * Results: + * A TCL status code + * + * Side effects: + * None. + */ + + int TkUndoApply ( stack, interp ) + TkUndoRedoStack * stack; + Tcl_Interp * interp; + { + 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(interp,elem->apply,TCL_EVAL_GLOBAL); + + TkUndoPushStack(&(stack->undoStack), elem); + elem = TkUndoPopStack(&(stack->redoStack)); + } + + /* insert a separator on the undo stack */ + + TkUndoInsertSeparator(&(stack->undoStack)); + + return TCL_OK; + } + 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 Sat May 18 09:10:00 2002 *************** *** 0 **** --- 1,77 ---- + /* + * 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 * 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 */ + } TkUndoRedoStack; + + /* basic functions */ + + 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)); + + /* functions working on an undo/redo stack */ + + EXTERN TkUndoRedoStack * TkUndoInitStack _ANSI_ARGS_(()); + + 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, + Tcl_Interp * interp)); + + EXTERN int TkUndoApply _ANSI_ARGS_((TkUndoRedoStack * stack, + Tcl_Interp * interp)); + + #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 11:42:20 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 11:42:20 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 11:42:20 2002 *************** *** 339,344 **** --- 339,345 ---- tkTextTag.$(OBJEXT) \ tkTextWind.$(OBJEXT) \ tkTrig.$(OBJEXT) \ + tkUndo.$(OBJEXT) \ tkUtil.$(OBJEXT) \ tkVisual.$(OBJEXT) \ tkStubInit.$(OBJEXT) \