Tk Source Code

of the widget to \fIboolean\fR.
.TP
\fIpathName \fBedit redo\fR
.
When the \fB\-undo\fR option is true, reapplies the last undone edits provided
no other edits were done since then. Generates an error when the redo stack is
empty. Does nothing when the \fB\-undo\fR option is false.
.TP
\fIpathName \fBedit redodepth\fR
.
Returns the depth of the redo stack (number of redoable actions). When this is
zero there is nothing to redo. When the \fB\-undo\fR option is false zero is
returned.
.TP
\fIpathName \fBedit reset\fR
.
Clears the undo and redo stacks.
.TP
\fIpathName \fBedit separator\fR
.
Inserts a separator (boundary) on the undo stack. Does nothing when the
\fB\-undo\fR option is false.
.TP
\fIpathName \fBedit undo\fR
.
Undoes the last edit action when the \fB\-undo\fR option is true. An edit
action is defined as all the insert and delete commands that are recorded on
the undo stack in between two separators. Generates an error when the undo
stack is empty. Does nothing when the \fB\-undo\fR option is false.
.TP
\fIpathName \fBedit undodepth\fR
.
Returns the depth of the undo stack (number of undoable actions). When this is
zero there is nothing to undo. When the \fB\-undo\fR option is false zero is
returned.
.RE
.TP
\fIpathName \fBget\fR ?\fB\-displaychars\fR? ?\fB\-\-\fR? \fIindex1\fR ?\fIindex2 ...\fR?
.
Return a range of characters from the text. The return value will be all the
characters in the text starting with the one whose index is \fIindex1\fR and
ending just before the one whose index is \fIindex2\fR (the character at

     * Copy down shared flags.
     */

    textPtr->sharedTextPtr->undo = textPtr->undo;
    textPtr->sharedTextPtr->maxUndo = textPtr->maxUndo;
    textPtr->sharedTextPtr->autoSeparators = textPtr->autoSeparators;

    TkUndoSetDepth(textPtr->sharedTextPtr->undoStack,
    TkUndoSetMaxDepth(textPtr->sharedTextPtr->undoStack,
	    textPtr->sharedTextPtr->maxUndo);

    /*
     * A few other options also need special processing, such as parsing the
     * geometry and setting the background from a 3-D border.
     */

    TkText *textPtr,		/* Information about text widget. */
    Tcl_Interp *interp,		/* Current interpreter. */
    int objc,			/* Number of arguments. */
    Tcl_Obj *const objv[])	/* Argument objects. */
{
    int index, setModified, oldModified;
    static const char *const editOptionStrings[] = {
	"modified", "redo", "reset", "separator", "undo", NULL
	"modified", "redo", "redodepth", "reset", "separator", "undo",
        "undodepth", NULL
    };
    enum editOptions {
	EDIT_MODIFIED, EDIT_REDO, EDIT_RESET, EDIT_SEPARATOR, EDIT_UNDO
	EDIT_MODIFIED, EDIT_REDO, EDIT_REDODEPTH, EDIT_RESET,
        EDIT_SEPARATOR, EDIT_UNDO, EDIT_UNDODEPTH
    };

    if (objc < 3) {
	Tcl_WrongNumArgs(interp, 2, objv, "option ?arg ...?");
	return TCL_ERROR;
    }

	}
	if (TextEditRedo(textPtr)) {
	    Tcl_SetObjResult(interp, Tcl_NewStringObj("nothing to redo", -1));
	    Tcl_SetErrorCode(interp, "TK", "TEXT", "NO_REDO", NULL);
	    return TCL_ERROR;
	}
	break;
    case EDIT_REDODEPTH: {
        int depth = 0;

        if (objc != 3) {
            Tcl_WrongNumArgs(interp, 3, objv, NULL);
            return TCL_ERROR;
        }
        if (textPtr->sharedTextPtr->undo) {
            depth = TkUndoGetDepth(textPtr->sharedTextPtr->undoStack, 1);
        }
        Tcl_SetObjResult(interp, Tcl_NewIntObj(depth));
        break;
    }
    case EDIT_RESET:
	if (objc != 3) {
	    Tcl_WrongNumArgs(interp, 3, objv, NULL);
	    return TCL_ERROR;
	}
	TkUndoClearStacks(textPtr->sharedTextPtr->undoStack);
	break;

	}
	if (TextEditUndo(textPtr)) {
	    Tcl_SetObjResult(interp, Tcl_NewStringObj("nothing to undo", -1));
	    Tcl_SetErrorCode(interp, "TK", "TEXT", "NO_UNDO", NULL);
	    return TCL_ERROR;
	}
	break;
    case EDIT_UNDODEPTH: {
        int depth = 0;

        if (objc != 3) {
            Tcl_WrongNumArgs(interp, 3, objv, NULL);
            return TCL_ERROR;
        }
        if (textPtr->sharedTextPtr->undo) {
            depth = TkUndoGetDepth(textPtr->sharedTextPtr->undoStack, 0);
        }
        Tcl_SetObjResult(interp, Tcl_NewIntObj(depth));
        break;
    }
    }
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *

    stack->depth = 0;
    return stack;
}

/*
 *----------------------------------------------------------------------
 *
 * TkUndoSetDepth --
 * TkUndoSetMaxDepth --
 *
 *	Set the maximum depth of stack.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May delete elements from the stack if the new maximum depth is smaller
 *	than the number of elements previously in the stack.
 *
 *----------------------------------------------------------------------
 */

void
TkUndoSetDepth(
TkUndoSetMaxDepth(
    TkUndoRedoStack *stack,	/* An Undo/Redo stack */
    int maxdepth)		/* The maximum stack depth */
{
    stack->maxdepth = maxdepth;

    if (stack->maxdepth>0 && stack->depth>stack->maxdepth) {
	TkUndoAtom *elem, *prevelem;

	    }
	    elem = elem->next;
	    ckfree(prevelem);
	}
	stack->depth = stack->maxdepth;
    }
}

/*
 *----------------------------------------------------------------------
 *
 * TkUndoGetDepth
 *
 *	Return the depth of the undo (or redo) stack.
 *
 * Results:
 *	An integer representing the number of undoable (or redoable) actions.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

int
TkUndoGetDepth(
    TkUndoRedoStack *stack,	/* An Undo/Redo stack */
    int whichStack)		/* 0 means the undo stack,
                                 * otherwise the redo stack */
{
    int depth = 0;
    TkUndoAtom *elem = NULL;

    if (stack != NULL) {
        if (whichStack) {
            elem = stack->redoStack;
        } else {
            elem = stack->undoStack;
        }

        if (elem != NULL) {
            /*
             * Skip the first (top) separator if there is one.
             */

            if (elem->type == TK_UNDO_SEPARATOR) {
                elem = elem->next;
            }

            /*
             * The number of compound actions in the stack is then
             * the number of separators plus one, except if there is
             * a separator at the bottom of the stack. This latter
             * case cannot however happen (TkUndoInsertSeparator
             * prevents from inserting a separator there).
             */

            while (elem != NULL) {
                if (elem->type == TK_UNDO_SEPARATOR) {
                    depth++;
                }
                elem = elem->next;
            }
            depth++;
        }
    }
    return depth;
}

/*
 *----------------------------------------------------------------------
 *
 * TkUndoClearStacks --
 *
 *	Clear both the undo and redo stack.

void
TkUndoInsertUndoSeparator(
    TkUndoRedoStack *stack)
{
    if (TkUndoInsertSeparator(&stack->undoStack)) {
	stack->depth++;
	TkUndoSetDepth(stack, stack->maxdepth);
	TkUndoSetMaxDepth(stack, stack->maxdepth);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * TkUndoRevert --

MODULE_SCOPE void	TkUndoClearStack(TkUndoAtom **stack);

/*
 * Functions for working on an undo/redo stack.
 */

MODULE_SCOPE TkUndoRedoStack *TkUndoInitStack(Tcl_Interp *interp, int maxdepth);
MODULE_SCOPE void	TkUndoSetDepth(TkUndoRedoStack *stack, int maxdepth);
MODULE_SCOPE void	TkUndoSetMaxDepth(TkUndoRedoStack *stack, int maxdepth);
MODULE_SCOPE int	TkUndoGetDepth(TkUndoRedoStack *stack, int whichStack);
MODULE_SCOPE void	TkUndoClearStacks(TkUndoRedoStack *stack);
MODULE_SCOPE void	TkUndoFreeStack(TkUndoRedoStack *stack);
MODULE_SCOPE void	TkUndoInsertUndoSeparator(TkUndoRedoStack *stack);
MODULE_SCOPE TkUndoSubAtom *TkUndoMakeCmdSubAtom(Tcl_Command command,
			    Tcl_Obj *actionScript, TkUndoSubAtom *subAtomList);
MODULE_SCOPE TkUndoSubAtom *TkUndoMakeSubAtom(TkUndoProc *funcPtr,
			    ClientData clientData, Tcl_Obj *actionScript,

    destroy .t
} -returnCodes {error} -result {wrong # args: should be ".t edit option ?arg ...?"}
test text-27.2 {TextEditCmd procedure, argument parsing} -body {
    pack [text .t]
    .t edit gorp
} -cleanup {
    destroy .t
} -returnCodes {error} -result {bad edit option "gorp": must be modified, redo, reset, separator, or undo}
} -returnCodes {error} -result {bad edit option "gorp": must be modified, redo, redodepth, reset, separator, undo, or undodepth}
test text-27.3 {TextEditUndo procedure, undoing changes} -body {
    text .t -undo 1
    pack .t
    .t insert end "line 1\n"
    .t delete 1.4 1.6
    .t insert end "should be gone after undo\n"
    .t edit undo

    event generate .top.t <<Cut>>
    event generate .top.t <Delete>
    event generate .top.t <<Undo>>
    .top.t get 1.0 "1.0 lineend"
} -cleanup {
    destroy .top.t .top
} -result "This A an example text"
test text-27.24 {TextEditCmd procedure, undo and redo stack depths} -setup {
    destroy .t
    set res {}
} -body {
    text .t -undo false -autoseparators false
    lappend res [.t edit undodepth] [.t edit redodepth]
    .t configure -undo true
    lappend res [.t edit undodepth] [.t edit redodepth]
    .t insert end "DO\n"
    .t edit separator
    .t insert end "IT\n"
    .t insert end "YOURSELF\n"
    .t edit separator
    lappend res [.t edit undodepth] [.t edit redodepth]
    .t edit undo
    lappend res [.t edit undodepth] [.t edit redodepth]
    .t configure -undo false
    lappend res [.t edit undodepth] [.t edit redodepth]
    .t configure -undo true
    lappend res [.t edit undodepth] [.t edit redodepth]
    .t edit redo
    lappend res [.t edit undodepth] [.t edit redodepth]
} -cleanup {
    destroy .t
} -result {0 0 0 0 2 0 1 1 0 0 1 1 2 0}


test text-28.1 {bug fix - 624372, ControlUtfProc long lines} -body {
    pack [text .t -wrap none]
    .t insert end [string repeat "\1" 500]
} -cleanup {
    destroy .t
} -result {}