Tk Source Code

	TkTextIndexSave(&textPtr->topIndex);
	if (triggerWatch) {
	    TkTextSaveCursorIndex(textPtr);
	}

	TkTextMarkSegToIndex(textPtr, textPtr->insertMarkPtr, &index);

	if (TkTextIndexCompare(&indexFrom, &index) < 0 && TkTextIndexCompare(&index, &indexTo) <= 0) {
	    /*
	     * The insertion point is inside the range to be replaced, so
	     * we have to do some calculations to ensure it doesn't move
	     * unnecessarily.
	     */

	    int deleteInsertOffset, insertLength, j;

		    TkTextClearTags(sharedTextPtr, textPtr, &index1, &index3, false);
		} else {
		    assert(TkTextTagSetIsEmpty(lastLinePtr->prevPtr->lastPtr->tagInfoPtr));
		}
	    }
	    return true; /* nothing to do */
	}

	if (lastLinePtr->prevPtr->lastPtr->tagInfoPtr != sharedTextPtr->emptyTagInfoPtr) {
	    /* last newline is tagged, so we have to re-include this character */
	    index2 = index3;
	}
    }

    /*
     * Call the "watch" command for deletion. Take into account that the
     * receiver might change the text content inside the callback, although
     * he shouldn't do this.
     */

 * Used as 'action' values in calls to TkTextInvalidateLineMetrics
 */

typedef enum {
    TK_TEXT_INVALIDATE_ONLY,
    TK_TEXT_INVALIDATE_INSERT,
    TK_TEXT_INVALIDATE_DELETE,
    TK_TEXT_INVALIDATE_ELIDE,
    TK_TEXT_INVALIDATE_REINSERTED
} TkTextInvalidateAction;

/*
 * Used as special 'pickPlace' values in calls to TkTextSetYView. Zero or
 * positive values indicate a number of pixels.
 */

{
    const UndoTokenDelete *token = (const UndoTokenDelete *) undoInfo->token;

    if (token->startIndex.lineIndex == -1 && token->endIndex.lineIndex == -1) {
	TkTextSegment *segPtr1 = token->startIndex.u.markPtr;
	TkTextSegment *segPtr2 = token->endIndex.u.markPtr;
	int flags = token->inclusive ? DELETE_INCLUSIVE : 0;

	if (redoInfo) {
	    UndoTokenDelete *redoToken;

	    redoToken = malloc(sizeof(UndoTokenDelete));
	    redoToken->undoType = &undoTokenDeleteType;
	    redoToken->segments = NULL;
	    redoToken->numSegments = 0;
	    redoToken->startIndex = token->startIndex;
	    redoToken->endIndex = token->endIndex;
	    redoInfo->token = (TkTextUndoToken *) redoToken;
	    redoInfo->byteSize = 0;
	    DEBUG_ALLOC(tkTextCountNewUndoToken++);
	}

	DeleteRange(sharedTextPtr, segPtr1, segPtr2, flags, redoInfo);

	assert(segPtr1 != segPtr2);
	segPtr1->protectionFlag = true;
	segPtr2->protectionFlag = true;
	CleanupSplitPoint(segPtr1, sharedTextPtr);

    int changeToPixels = 0;

    assert(textPtr->pixelReference != -1);

    for ( ; numLines > 0; --numLines) {
	TkTextPixelInfo *pixelInfo = TkBTreeLinePixelInfo(textPtr, linePtr);

	pixelInfo = TkBTreeLinePixelInfo(textPtr, linePtr);
	changeToDispLines += (int) GetDisplayLines(linePtr, pixelReference);
	changeToPixels += pixelInfo->height;
	pixelInfo->epoch = 0;
	pixelInfo->height = 0;
	linePtr = linePtr->nextPtr;

	if (pixelInfo->dispLineInfo) {
	    free(pixelInfo->dispLineInfo);
	    pixelInfo->dispLineInfo = NULL;
	    DEBUG_ALLOC(tkTextCountDestroyDispInfo++);
	}

	if (!linePtr) {
	    assert(numLines == 1);
	    break;
	}
	
	if (nodePtr != linePtr->parentPtr) {
	    PropagateDispLineChange(nodePtr, pixelReference, changeToDispLines, changeToPixels);
	    changeToDispLines = 0;
	    changeToPixels = 0;
	    nodePtr = linePtr->parentPtr;
	}
    }

	    TkTextIndexSetSegment(&index, beforeSurrogate);
	} else {
	    TkTextIndexSetupToStartOfText(&index, NULL, sharedTextPtr->tree);
	}
	DEBUG(tkBTreeDebug = false); /* otherwise protected segment will be complained */
	TkBTreeInsertChars(sharedTextPtr->tree, &index, "\n",
		sharedTextPtr->emptyTagInfoPtr, NULL, NULL);
	/* don't forget to reset pixel info of very last line */
	TkTextInvalidateLineMetrics(treePtr->sharedTextPtr, NULL,
		sharedTextPtr->endMarker->sectionPtr->linePtr, 0, TK_TEXT_INVALIDATE_REINSERTED);
	DEBUG(tkBTreeDebug = oldTreeDebug);
    }
}

/*
 *----------------------------------------------------------------------
 *

    unsigned totalLines = TkBTreeNumLines(textPtr->sharedTextPtr->tree, textPtr);
    unsigned epoch = textPtr->dInfoPtr->lineMetricUpdateEpoch;
    bool isMonospaced = UseMonospacedLineHeights(textPtr);
    unsigned lineNum = 0; /* suppress compiler warning */

    assert(linePtr || action == TK_TEXT_INVALIDATE_ONLY);
    assert(TkBTreeLinesTo(textPtr->sharedTextPtr->tree, textPtr, linePtr, NULL) + lineCount
	    < totalLines + (action == TK_TEXT_INVALIDATE_INSERT
			    || action == TK_TEXT_INVALIDATE_DELETE
			    || action == TK_TEXT_INVALIDATE_REINSERTED));

    if (linePtr) {
	int deviation;

	lineNum = TkBTreeLinesTo(textPtr->sharedTextPtr->tree, textPtr, linePtr, &deviation);


	assert(deviation >= 0);

	if (deviation) {
	    lineCount -= MIN((int) lineCount, deviation);
	}
	if (action == TK_TEXT_INVALIDATE_INSERT
	    	&& !isMonospaced

	    int high = TkRangeListHigh(ranges);

	    TkRangeListClear(ranges);
	    ranges = TkRangeListAdd(ranges, low, high);
	}

	switch (action) {
	case TK_TEXT_INVALIDATE_REINSERTED: {
	    /*
	     * Special case: the very last line has been re-inserted.
	     */
	    assert(lineNum == totalLines);
	    assert(lineNum > 0);
	    TkRangeListTruncateAtEnd(ranges, lineNum - 1);
	    TkBTreeResetDisplayLineCounts(textPtr, linePtr, 1);
	    break;
	}
	case TK_TEXT_INVALIDATE_ONLY: {
	    int counter = MIN(lineCount, totalLines - lineNum);

	    if (isMonospaced) {
		TkBTreeUpdatePixelHeights(textPtr, linePtr, lineCount, epoch);
	    } else {
		TkTextLine *logicalLinePtr;

		    FreeDLines(textPtr, dlPtr, FindDLine(textPtr, dlPtr, &index), DLINE_UNLINK);
		}
	    }
	    if (lineNum + lineCount < totalLines) {
		ranges = TkRangeListAdd(ranges, lineNum, lineNum);
	    } else {
		TkRangeListTruncateAtEnd(ranges, lineNum - 1);
		ResetPixelInfo(TkBTreeLinePixelInfo(textPtr,
			textPtr->sharedTextPtr->endMarker->sectionPtr->linePtr));
	    }
	    ResetPixelInfo(TkBTreeLinePixelInfo(textPtr,
		    TkBTreeGetLogicalLine(textPtr->sharedTextPtr, textPtr, linePtr)));
	    break;
	case TK_TEXT_INVALIDATE_INSERT:
	    if (lineCount > 0 && lineNum + 1 < totalLines) {
		int lastLine = MIN(lineNum + lineCount, totalLines - 1);

} -cleanup {
    destroy $w
} -result {}

test text-37.1 {deletion - newline behavior - undo/redo behavior} -setup {
    text .t -undo on
    .t insert end "1" {} "\n" n1 "2" {}

    set res {}
} -body {
    .t delete begin end
    lappend res [.t inspect -chars -tag]
    .t edit undo
    lappend res [.t inspect -chars -tag]
    .t edit redo
    lappend res [.t inspect -chars -tag]
    set res
} -cleanup {
    destroy .t
    unset res
} -result {{{break {}}}\
    {{text 1 {}} {break {n1}} {text 2 {}} {break {}}}\
    {{break {}}}}
test text-37.2 {deletion - newline behavior - undo/redo behavior} -setup {
    text .t -undo on
    .t insert end "1" {} "\n" n1 "2" {}

    set res {}
} -body {
    .t delete 2.0 end
    lappend res [.t inspect -chars -tag]
    .t edit undo
    lappend res [.t inspect -chars -tag]
    .t edit redo
    lappend res [.t inspect -chars -tag]
    set res
} -cleanup {
    destroy .t
    unset res
} -result {{{text 1 {}} {break {n1}} {break {}}}\
    {{text 1 {}} {break {n1}} {text 2 {}} {break {}}}\
    {{text 1 {}} {break {n1}} {break {}}}}
test text-37.3 {deletion - newline behavior - undo/redo behavior} -setup {
    text .t -undo on
    .t insert end "1" {} "\n" n1 "2" {}

    set res {}
} -body {
    .t delete 1.end end
    lappend res [.t inspect -chars -tag]
    .t edit undo
    lappend res [.t inspect -chars -tag]
    .t edit redo
    lappend res [.t inspect -chars -tag]
    set res
} -cleanup {
    destroy .t
    unset res
} -result {{{text 1 {}} {break {}}}\
    {{text 1 {}} {break {n1}} {text 2 {}} {break {}}}\
    {{text 1 {}} {break {}}}}
test text-37.4 {deletion - newline behavior - undo/redo behavior} -setup {
    text .t -undo on
    .t insert end "1" {} "\n" n1 "2" {}

    set res {}
} -body {
    .t delete 2.end end
    lappend res [.t inspect -chars -tag]
    .t edit undo
    lappend res [.t inspect -chars -tag]
    .t edit redo
    lappend res [.t inspect -chars -tag]
    set res
} -cleanup {
    destroy .t
    unset res
} -result {{{text 1 {}} {break {n1}} {text 2 {}} {break {}}}\
    {{break {}}}\
    {{text 1 {}} {break {n1}} {text 2 {}} {break {}}}}
test text-37.5 {deletion - newline behavior - undo/redo behavior} -setup {
    text .t -undo on
    .t insert end "1" {} "\n" n1 "2" {} "\n" {n2}

    set res {}
} -body {
    .t delete begin end
    lappend res [.t inspect -chars -tag]
    .t edit undo
    lappend res [.t inspect -chars -tag]
    .t edit redo
    lappend res [.t inspect -chars -tag]
    set res
} -cleanup {
    destroy .t
    unset res
} -result {{{break {}}}\
    {{text 1 {}} {break {n1}} {text 2 {}} {break {n2}} {break {}}}\
    {{break {}}}}
test text-37.6 {deletion - newline behavior - undo/redo behavior} -setup {
    text .t -undo on
    .t insert end "1" {} "\n" n1 "2" {} "\n" {n2}

    set res {}
} -body {
    .t delete 2.0 end
    lappend res [.t inspect -chars -tag]
    .t edit undo
    lappend res [.t inspect -chars -tag]
    .t edit redo
    lappend res [.t inspect -chars -tag]
    set res
} -cleanup {
    destroy .t
    unset res
} -result {{{text 1 {}} {break {n1}} {break {}}}\
    {{text 1 {}} {break {n1}} {text 2 {}} {break {n2}} {break {}}}\
    {{text 1 {}} {break {n1}} {break {}}}}
test text-37.7 {deletion - newline behavior - undo/redo behavior} -setup {
    text .t -undo on
    .t insert end "1" {} "\n" n1 "2" {} "\n" {n2}

    set res {}
} -body {
    .t delete 1.end end
    lappend res [.t inspect -chars -tag]
    .t edit undo
    lappend res [.t inspect -chars -tag]
    .t edit redo
    lappend res [.t inspect -chars -tag]
    set res
} -cleanup {
    destroy .t
    unset res
} -result {{{text 1 {}} {break {}}}\
    {{text 1 {}} {break {n1}} {text 2 {}} {break {n2}} {break {}}}\
    {{text 1 {}} {break {}}}}
test text-37.8 {deletion - newline behavior - undo/redo behavior} -setup {
    text .t -undo on
    .t insert end "1" {} "\n" n1 "2" {} "\n" {n2}

    set res {}
} -body {
    .t delete 2.end end
    lappend res [.t inspect -chars -tag]
    .t edit undo
    lappend res [.t inspect -chars -tag]
    .t edit redo
    lappend res [.t inspect -chars -tag]
    set res
} -cleanup {
    destroy .t
    unset res
} -result {{{text 1 {}} {break {n1}} {text 2 {}} {break {}}}\
    {{text 1 {}} {break {n1}} {text 2 {}} {break {n2}} {break {}}}\
    {{text 1 {}} {break {n1}} {text 2 {}} {break {}}}}
test text-37.9 {deletion - newline behavior - undo/redo behavior} -setup {
    text .t -undo on
    .t tag add n begin
    .t edit separator -immediately

    set res {}
} -body {
    .t delete begin end
    lappend res [.t inspect -chars -tag]
    .t edit undo
    lappend res [.t inspect -chars -tag]
    .t edit redo
    lappend res [.t inspect -chars -tag]
    set res
} -cleanup {
    destroy .t
    unset res
} -result {{{break {}}}\
    {{break {n}}}\
    {{break {}}}}
test text-37.10 {deletion - clean widget} -setup {
    text .t -undo on

    set res {}
} -body {
    lappend res [.t inspect -chars -tag]
    .t delete begin end
    lappend res [.t inspect -chars -tag]
    catch {
	.t edit undo
	lappend res [.t inspect -chars -tag]
    }
    set res
} -cleanup {
   destroy .t
   unset res
} -result {{{break {}}}\
    {{break {}}}}
test text-37.11 {deletion - test optimization} -setup {
    text .t -undo on
    .t tag add n begin
    .t edit separator -immediately
} -body {
    .t delete begin end
    .t edit inspect
} -cleanup {
    destroy .t
} -result {{{{tag clear {n 0 1}}} {{tag add n}}} {}}
test text-37.12 {deletion - newline behavior - undo/redo behavior} -setup {
    text .t -undo on
    .t insert end "1"
    .t tag add n begin end
    .t edit separator -immediately
    set res {}
} -body {
    .t delete begin end
    lappend res [.t inspect -chars -tag]
    .t edit undo
    lappend res [.t inspect -chars -tag]
    .t edit redo
    lappend res [.t inspect -chars -tag]
    set res
} -cleanup {
    destroy .t
    unset res
} -result {{{break {}}}\
    {{break {}} {text 1 {n}} {break {n}}}\
    {{break {}}}}

# cleanup
cleanupTests
return

# Local Variables:
# mode: tcl