Tk Source Code

    const TkSharedText *sharedTextPtr;
    Node *nodePtr, *parentPtr;
    unsigned pixelReference;
    unsigned index;

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

    if (linePtr == TkBTreeGetStartLine(textPtr)) {
	return 0;
    }

    pixelReference = textPtr->pixelReference;
    sharedTextPtr = textPtr->sharedTextPtr;

    TkTextPixelInfo *pixelInfo = TkBTreeLinePixelInfo(textPtr, linePtr);
    unsigned oldNumDispLines = TkBTreeGetNumberOfDisplayLines(pixelInfo);
    TkTextDispLineInfo *dispLineInfo;
    TkTextLine *nextLogicalLinePtr;

    assert(dlPtr->byteCount > 0);
    assert(linePtr->logicalLine);
    assert(TkTextIndexGetLine(&dlPtr->index));
    assert(linePtr == TkBTreeGetLogicalLine(
	    textPtr->sharedTextPtr, textPtr, TkTextIndexGetLine(&dlPtr->index)));

    if (pixelInfo->epoch == epoch) {
	int lineNo = TkBTreeLinesTo(textPtr->sharedTextPtr->tree, textPtr, linePtr, NULL);

	if (TkRangeListContains(textPtr->dInfoPtr->lineMetricUpdateRanges, lineNo)) {

    unsigned countChunks;
    unsigned chunksPerSection;
    int length, offset;

    assert(displayLineNo >= 0);
    assert((displayLineNo == 0) ==
	    (IsStartOfNotMergedLine(indexPtr) || TkTextIndexIsStartOfText(indexPtr)));
    assert(indexPtr);
    assert(TkTextIndexGetLine(indexPtr));

    DEBUG(stats.numLayouted += 1);

    textPtr = indexPtr->textPtr;
    assert(textPtr);
    dInfoPtr = textPtr->dInfoPtr;

    TkTextLine *logicalLinePtr;
    TkTextLine *linePtr;
    unsigned byteOffset;
    unsigned startByteOffset;
    unsigned viewHeight;

    assert(info);
    assert(TkTextIndexGetLine(indexPtr));

    linePtr = TkTextIndexGetLine(indexPtr);
    logicalLinePtr = TkBTreeGetLogicalLine(textPtr->sharedTextPtr, textPtr, linePtr);
    pixelInfo = TkBTreeLinePixelInfo(textPtr, logicalLinePtr);
    dispLineInfo = pixelInfo->dispLineInfo;
    info->index = *indexPtr;
    TkTextIndexSetToStartOfLine2(&info->index, logicalLinePtr);

    assert(textPtr->sharedTextPtr->allowUpdateLineMetrics);

    while (range) {
	TkTextLine *linePtr;
	TkTextLine *logicalLinePtr;
	int lineNum = range->low;
	int high = range->high;

	assert(lineNum < TkBTreeNumLines(textPtr->sharedTextPtr->tree, textPtr));

	linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree, textPtr, lineNum);
	logicalLinePtr = TkBTreeGetLogicalLine(textPtr->sharedTextPtr, textPtr, linePtr);

	if (linePtr != logicalLinePtr) {
	    lineNum = TkBTreeLinesTo(textPtr->sharedTextPtr->tree, textPtr, logicalLinePtr, NULL);
	    linePtr = logicalLinePtr;

    if ((range = TkRangeListFindNearest(dInfoPtr->lineMetricUpdateRanges, lineNum))) {
	TkTextLine *linePtr = NULL;
	unsigned count = 0;
	unsigned high = range->high;

	lineNum = range->low;
	endLine = MIN((int) endLine, TkBTreeNumLines(textPtr->sharedTextPtr->tree, textPtr) - 1);
	assert((int) lineNum < TkBTreeNumLines(textPtr->sharedTextPtr->tree, textPtr));

	while (true) {
	    const TkTextPixelInfo *pixelInfo;
	    int firstLineNum;

	    if (lineNum > high) {
		/*

    TkTextLine *linePtr2;
    TkTextIndex index;
    unsigned byteOffset;
    int numLines;

    assert(TkTextIndexCompare(indexFrom, indexTo) <= 0);
    assert(textPtr->sharedTextPtr->allowUpdateLineMetrics);
    assert(TkTextIndexGetLine(indexFrom));
    assert(TkTextIndexGetLine(indexTo));

    TkTextUpdateLineMetrics(textPtr, TkTextIndexGetLineNumber(indexFrom, textPtr),
	    TkTextIndexGetLineNumber(indexTo, textPtr));

    linePtr1 = TkBTreeGetLogicalLine(textPtr->sharedTextPtr, textPtr, TkTextIndexGetLine(indexFrom));
    linePtr2 = TkBTreeGetLogicalLine(textPtr->sharedTextPtr, textPtr, TkTextIndexGetLine(indexTo));
    pixelInfo1 = linePtr1->pixelInfo;

    TkTextLine *logicalLinePtr;
    const TkTextPixelInfo *pixelInfo;
    TkTextDispLineInfo *dispLineInfo;
    const TkTextDispLineEntry *lastEntry;
    const TkTextDispLineEntry *entry;
    TkTextIndex index;
    unsigned byteOffset;

    assert(TkTextIndexGetLine(indexPtr));

    logicalLinePtr = TkBTreeGetLogicalLine(textPtr->sharedTextPtr, textPtr,
	    TkTextIndexGetLine(indexPtr));
    if (logicalLinePtr == TkBTreeGetLastLine(textPtr)) {
	return 0;
    }
    pixelInfo = TkBTreeLinePixelInfo(textPtr, logicalLinePtr);

    TkTextLine *logicalLinePtr;
    TkTextPixelInfo *pixelInfo;
    unsigned displayLines;
    unsigned updateCounter;
    unsigned pixelHeight;

    assert(linePtr != TkBTreeGetLastLine(textPtr));
    assert(TkTextIndexGetLine(indexPtr));

    if (!indexPtr) {
	TkTextIndexClear(&index, textPtr);
	TkTextIndexSetToStartOfLine2(&index, linePtr);
	indexPtr = &index;
    }

{
    TextDInfo *dInfoPtr = textPtr->dInfoPtr;
    TkTextLine *lastLinePtr = TkBTreeGetLastLine(textPtr);
    DLine *firstPtr = NULL;
    DLine *lastPtr= NULL;
    TkTextIndex rounded;
    TkTextLine *linePtr;

    assert(TkTextIndexGetLine(index1Ptr));

    /*
     * Find the DLines corresponding to index1Ptr and index2Ptr. There is one
     * tricky thing here, which is that we have to relayout in units of whole
     * text lines: This is necessary because the indices stored in the display
     * lines will no longer be valid. It's also needed because any edit could
     * change the way lines wrap.

    lastLinePtr = TkBTreeGetLastLine(textPtr);

    if (linePtr != lastLinePtr) {
	int byteOffset = FindDisplayLineOffset(textPtr, linePtr, &pixelOffset);
	TkTextIndexSetByteIndex2(indexPtr, linePtr, byteOffset);
    } else {
	assert(lastLinePtr->prevPtr); /* MakePixelIndex will not be called if peer is empty */
	assert(linePtr->prevPtr);
	linePtr = TkBTreeGetLogicalLine(textPtr->sharedTextPtr, textPtr, linePtr->prevPtr);
	TkTextIndexSetToLastChar2(indexPtr, linePtr);
	FindDisplayLineStartEnd(textPtr, indexPtr, DISP_LINE_START, DLINE_CACHE);
	pixelOffset = CalculateDisplayLineHeight(textPtr, indexPtr, NULL) - 1;
    }

    return MAX(0, pixelOffset);