Tk Source Code

		result = TCL_ERROR;
		goto done;
	    }
	}

	for (; i < objc; i += 2) {
	    TkTextIndex index1, index2;
            Tcl_Obj *get;

	    if (!TkTextGetIndexFromObj(interp, textPtr, objv[i], &index1)) {
		if (objPtr) {
		    Tcl_DecrRefCount(objPtr);
		}
		result = TCL_ERROR;
		goto done;

	    /*
	     * We want to move the text we get from the window into the
	     * result, but since this could in principle be a megabyte or
	     * more, we want to do it efficiently!
	     */

	    get = TextGetText(textPtr, &index1, &index2, NULL, NULL, UINT_MAX,
		    visibleOnly, includeHyphens);

	    if (++found == 1) {
		Tcl_SetObjResult(interp, get);
	    } else {
		if (found == 2) {
		    /*

    int compare = TkTextIndexCompare(indexPtr1, indexPtr2);

    if (compare == 0) {
	return 0;
    }
    if (compare > 0) {
	return -((int)TkTextIndexCount(textPtr, indexPtr2, indexPtr1, type));
    }
    return TkTextIndexCount(textPtr, indexPtr1, indexPtr2, type);
}

/*
 *----------------------------------------------------------------------
 *

		if (Tcl_ListObjGetElements(interp, tagPtr, &numTags, &tagNamePtrs) != TCL_OK) {
		    rc = TCL_ERROR;
		} else if (numTags > 0) {
		    TkTextTag *tagPtr;

		    tagInfoPtr = TkTextTagSetResize(NULL, sharedTextPtr->tagInfoSize);

		    for (i = 0; i < (unsigned)numTags; ++i) {
			tagPtr = TkTextCreateTag(textPtr, Tcl_GetString(tagNamePtrs[i]), NULL);
#if !TK_TEXT_DONT_USE_BITFIELDS
			if (tagPtr->index >= TkTextTagSetSize(tagInfoPtr)) {
			    tagInfoPtr = TkTextTagSetResize(NULL, sharedTextPtr->tagInfoSize);
			}
#endif
			tagInfoPtr = TkTextTagSetAdd(tagInfoPtr, tagPtr->index);

    const TkSharedText *sharedTextPtr,
    Tcl_Obj *objPtr)
{
    if (sharedTextPtr->undoTagListCount > 0 || sharedTextPtr->undoMarkListCount > 0) {
	Tcl_Obj *resultPtr = Tcl_NewObj();
	int i;

	for (i = 0; i < (int)sharedTextPtr->undoTagListCount; ++i) {
	    TkTextInspectUndoTagItem(sharedTextPtr, sharedTextPtr->undoTagList[i], resultPtr);
	}

	for (i = 0; i < (int)sharedTextPtr->undoMarkListCount; ++i) {
	    TkTextInspectUndoMarkItem(sharedTextPtr, &sharedTextPtr->undoMarkList[i], resultPtr);
	}

	Tcl_ListObjLength(NULL, resultPtr, &i);
	if (i == 0) {
	    Tcl_IncrRefCount(resultPtr);
	    Tcl_DecrRefCount(resultPtr);

	segPtr = TkTextIndexGetContentSegment(&index, &offset1);
    }

    lastPtr = TkTextIndexGetContentSegment(indexPtr2, &offset2);

    if (segPtr == lastPtr) {
	if (segPtr->typePtr == &tkTextCharType) {
	    Tcl_AppendToObj(resultPtr, segPtr->body.chars + offset1, MIN((int)maxBytes, offset2 - offset1));
	}
    } else {
	TkTextLine *linePtr = segPtr->sectionPtr->linePtr;

	TkTextIndexClear(&index, textPtr);

	if (segPtr->typePtr == &tkTextCharType) {
	    unsigned nbytes = MIN((int)maxBytes, segPtr->size - offset1);
	    Tcl_AppendToObj(resultPtr, segPtr->body.chars + offset1, nbytes);
	    if ((maxBytes -= nbytes) == 0) {
		return resultPtr;
	    }
	} else if (segPtr->typePtr == &tkTextHyphenType) {
	    if (includeHyphens) {
		Tcl_AppendToObj(resultPtr, "\xc2\xad", 2); /* U+002D */

	if (!(segPtr = segPtr->nextPtr)) {
	    assert(linePtr->nextPtr);
	    linePtr = linePtr->nextPtr;
	    segPtr = linePtr->segPtr;
	}
	while (segPtr != lastPtr) {
	    if (segPtr->typePtr == &tkTextCharType) {
		unsigned nbytes = MIN((int)maxBytes, segPtr->size);
		Tcl_AppendToObj(resultPtr, segPtr->body.chars, nbytes);
		if ((maxBytes -= nbytes) == 0) {
		    if (lastIndexPtr) {
			TkTextIndexSetSegment(lastIndexPtr, segPtr);
			TkTextIndexAddToByteIndex(lastIndexPtr, nbytes);
		    }
		    return resultPtr; /* end of text reached */

	    if (!(segPtr = segPtr->nextPtr)) {
		assert(linePtr->nextPtr);
		linePtr = linePtr->nextPtr;
		segPtr = linePtr->segPtr;
	    }
	}
	if (offset2 > 0) {
	    Tcl_AppendToObj(resultPtr, segPtr->body.chars, MIN((int)maxBytes, offset2));
	}
    }

    return resultPtr;
}

/*

    return !segPtr->nextPtr;
}

static TkTextSegment *
GetPrevTagInfoSegment(
    TkTextSegment *segPtr)
{
    TkTextLine *linePtr;

    assert(segPtr);

    linePtr = segPtr->sectionPtr->linePtr;

    for (segPtr = segPtr->prevPtr; segPtr; segPtr = segPtr->prevPtr) {
	if (segPtr->tagInfoPtr) {
	    return segPtr;
	}
    }

    }

    /*
     * Increment the line and pixel counts in all the parent nodes of the
     * insertion point, then rebalance the tree if necessary.
     */

    SubtractPixelCount2(treePtr, nodePtr, -((int)changeToLineCount),
	    -((int)changeToLogicalLineCount), -((int)changeToBranchCount),
            -((int)size), changeToPixelInfo);
    linePtr->parentPtr->numChildren += changeToLineCount;

    if (nodePtr->numChildren > MAX_CHILDREN) {
	Rebalance(treePtr, nodePtr);
    }

    /*

    TkBTreeUndoIndexToIndex(sharedTextPtr, &token->endIndex, &endIndex);

    linePtr = TkTextIndexGetLine(&startIndex);
    segPtr = linePtr->segPtr;
    nodePtr = linePtr->parentPtr;

    for (i = 0; i < n; ++i, ++entry) {
	int skip = entry->skip;
	int size = entry->size;

	while (size > 0) {
	    while (linePtr->size - offs <= skip) {
		assert(linePtr->nextPtr);
		skip -= linePtr->size - offs;
		if (anyChanges) {
		    RecomputeLineTagInfo(linePtr, NULL, sharedTextPtr);

		prevPtr = SplitSeg(indexPtr, &info);
	    }
	    if (info.offset >= 0) {
		/*
		 * Fill increased/decreased char segment.
		 */
		segPtr = prevPtr;
		assert(segPtr->size >= info.offset + (int)chunkSize);
		memcpy(segPtr->body.chars + info.offset, string, chunkSize);
		segPtr->sectionPtr->size += chunkSize;
		linePtr->size += chunkSize;
		assert(!tagInfoPtr || TkTextTagSetIsEqual(tagInfoPtr, segPtr->tagInfoPtr));
		tagInfoPtr = segPtr->tagInfoPtr;
	    } else {
		/*

    }

    /*
     * Increment the line and pixel counts in all the parent nodes of the
     * insertion point, then rebalance the tree if necessary.
     */

    SubtractPixelCount2(treePtr, linePtr->parentPtr, -((int)changeToLineCount),
	    -((int)changeToLogicalLineCount), 0, -((int)size), changeToPixelInfo);

    if ((linePtr->parentPtr->numChildren += changeToLineCount) > MAX_CHILDREN) {
	Rebalance(treePtr, linePtr->parentPtr);
    }

    /*
     * This line now needs to have its height recalculated. This has to be done after Rebalance.

    sectionPtr = linePtr->segPtr->sectionPtr;

    assert(!sectionPtr || !sectionPtr->prevPtr);
    assert(!linePtr->lastPtr->nextPtr);
    assert(!propagateChangeOfNumBranches
	    || TkBTreeGetRoot(sharedTextPtr->tree)->numBranches >= linePtr->numBranches);

    changeToNumBranches = -(int)linePtr->numBranches;
    linePtr->numBranches = 0;
    linePtr->numLinks = 0;
    linePtr->size = 0;

    for (segPtr = linePtr->segPtr; segPtr; ) {
	if (!sectionPtr) {
	    TkTextSection *newSectionPtr;

    TkTextLine *linePtr)
{
    int i;

    assert(linePtr->parentPtr);
    DEBUG(linePtr->parentPtr = NULL);

    for (i = 0; i < (int)treePtr->numPixelReferences; ++i) {
	TkTextDispLineInfo *dispLineInfo = linePtr->pixelInfo[i].dispLineInfo;

	if (dispLineInfo) {
	    free(dispLineInfo);
	    DEBUG_ALLOC(tkTextCountDestroyDispInfo++);
	}
    }

    TkTextSegment *segPtr,	/* Copy text from this segment. */
    unsigned offset,		/* Copy text starting at this offset. */
    unsigned length,		/* Number of characters to copy. */
    unsigned newSize)		/* Character size of the new segment. */
{
    assert(segPtr);
    assert(segPtr->typePtr == &tkTextCharType);
    assert(segPtr->size >= (int)(offset + length));

    return MakeCharSeg(segPtr->sectionPtr, segPtr->tagInfoPtr, newSize,
	    segPtr->body.chars + offset, length);
}

/*
 *--------------------------------------------------------------

{
    TkTextSegment *newPtr1, *newPtr2;

    assert(segPtr);
    assert(segPtr->typePtr == &tkTextCharType);
    assert(segPtr->sectionPtr); /* otherwise segment is freed */
    assert(index > 0);
    assert((int)index < segPtr->size);

    newPtr1 = CopyCharSeg(segPtr, 0, index, index);
    newPtr2 = CopyCharSeg(segPtr, index, segPtr->size - index, segPtr->size - index);

    newPtr1->nextPtr = newPtr2;
    newPtr1->prevPtr = segPtr->prevPtr;
    newPtr2->nextPtr = segPtr->nextPtr;

static TkTextSegment *
PrepareInsertIntoCharSeg(
    TkTextSegment *segPtr,	/* Split or modify this segment. */
    unsigned offset,		/* Offset in segment. */
    SplitInfo *splitInfo)	/* Additional arguments. */
{
    unsigned oldCapacity, newCapacity;

    assert(splitInfo);
    assert(!splitInfo->splitted);
    assert(splitInfo->increase != 0);
    assert(segPtr);
    assert(segPtr->typePtr == &tkTextCharType);
    assert((int)offset <= segPtr->size);
    assert((int)offset < segPtr->size || segPtr->body.chars[segPtr->size - 1] != '\n');

    /*
     * We must not split if the new char content will be appended
     * to the current content (i.e. offset == segPtr->size).
     */

    if (splitInfo->forceSplit && (int)offset < segPtr->size) {
	unsigned newSize, decreasedSize;
	TkTextSegment *newPtr;

	splitInfo->splitted = true;

	if (offset == 0 && segPtr == segPtr->sectionPtr->linePtr->segPtr) {
	    /*

	segPtr->size = decreasedSize;
	newPtr->size = 0; /* temporary; LinkSegment() should not change total size */
	LinkSegment(segPtr->sectionPtr->linePtr, segPtr, newPtr);
	newPtr->size = newSize;
	SplitSection(segPtr->sectionPtr);
    }

    oldCapacity = CSEG_CAPACITY(segPtr->size);
    newCapacity = CSEG_CAPACITY(segPtr->size + splitInfo->increase);

    if (oldCapacity != newCapacity) {
	/*
	 * We replace this segment by a larger (or smaller) one.
	 */
	segPtr = IncreaseCharSegment(segPtr, offset, splitInfo->increase);
    } else {

		if (curNodePtr == nodePtr1 || curNodePtr == nodePtr2) {
		    /*
		     * Update only those nodes which will not be deleted,
		     * because DeleteEmptyNode will do a faster update.
		     */
		    SubtractPixelInfo(treePtr, curLinePtr);
		    if (curLinePtr->numBranches) {
			PropagateChangeOfNumBranches(curLinePtr->parentPtr, -(int)curLinePtr->numBranches);
		    }
		}

		if (--curNodePtr->numChildren == 0) {
		    DeleteEmptyNode(treePtr, curNodePtr);
		}
	    }

    if (!treePtr) {
	tree = textPtr->sharedTextPtr->tree;
	treePtr = (BTree *) tree;
    }

    nodePtr = treePtr->rootPtr;
    if (line < 0 || (int)nodePtr->numLines <= line) {
	return NULL;
    }

    /*
     * Check for any start/end offset for this text widget.
     */

    if (textPtr) {
	line += TkBTreeLinesTo(tree, NULL, TkBTreeGetStartLine(textPtr), NULL);
	if (line >= (int)nodePtr->numLines) {
	    return NULL;
	}
	if (line > (int)TkBTreeLinesTo(tree, NULL, TkBTreeGetLastLine(textPtr), NULL)) {
	    return NULL;
	}
    }

    if (line == 0) {
	return nodePtr->linePtr;
    }
    if (line == nodePtr->numLines - 1) {
	return nodePtr->lastPtr;
    }

    /*
     * Work down through levels of the tree until a node is found at level 0.
     */

    while (nodePtr->level > 0) {
	for (nodePtr = nodePtr->childPtr;
		nodePtr && (int)nodePtr->numLines <= line;
		nodePtr = nodePtr->nextPtr) {
	    line -= nodePtr->numLines;
	}
	assert(nodePtr);
    }

    /*

    pixelReference = textPtr->pixelReference;
    nodePtr = treePtr->rootPtr;

    if (0 > pixels) {
	return NULL;
    }
    if (pixels >= (int)nodePtr->pixelInfo[pixelReference].pixels) {
	return TkBTreeGetLastLine(textPtr);
    }

    /*
     * Work down through levels of the tree until a node is found at level 0.
     */

    while (nodePtr->level != 0) {
	for (nodePtr = nodePtr->childPtr;
		(int)nodePtr->pixelInfo[pixelReference].pixels <= pixels;
		nodePtr = nodePtr->nextPtr) {
	    assert(nodePtr);
	    pixels -= nodePtr->pixelInfo[pixelReference].pixels;
	}
    }

    /*
     * Work through the lines attached to the level-0 node.
     */

    for (linePtr = nodePtr->linePtr;
	    (int)linePtr->pixelInfo[pixelReference].height <= pixels;
	    linePtr = linePtr->nextPtr) {
	assert(linePtr != nodePtr->lastPtr->nextPtr);
	pixels -= linePtr->pixelInfo[pixelReference].height;
    }

    assert(linePtr);

    }

    if (!(flags & HAS_TAGON)) {
	flags &= ~HAS_TAGOFF;
    } else if (nchilds < nodePtr->numChildren) {
	flags |= HAS_TAGOFF;
    }
    if (nchilds > (unsigned)(nodePtr->level > 0 ? 1 : 0)) {
	tagPtr->rootPtr = nodePtr;
    }

    nodePtr->tagonPtr = TagSetAddOrErase(nodePtr->tagonPtr, tagPtr, !!(flags & HAS_TAGON));
    nodePtr->tagoffPtr = TagSetAddOrErase(nodePtr->tagoffPtr, tagPtr, !!(flags & HAS_TAGOFF));

    return flags;

    unsigned memsize;

    if (nodePtr->level == 0 && !nodePtr->linePtr) {
	Tcl_Panic("CheckNodeConsistency: this node is freed");
    }

    minChildren = nodePtr->parentPtr ? MIN_CHILDREN : (nodePtr->level > 0 ? 2 : 1);
    if ((int)nodePtr->numChildren < minChildren || (int)nodePtr->numChildren > MAX_CHILDREN) {
	Tcl_Panic("CheckNodeConsistency: bad child count (%d)", nodePtr->numChildren);
    }

    if (!nodePtr->linePtr) {
	Tcl_Panic("CheckNodeConsistency: first pointer is NULL");
    }
    if (!nodePtr->lastPtr) {

    TkTextTagSetIncrRefCount(tagoffPtr = sharedTextPtr->emptyTagInfoPtr);
    additionalTagoffPtr = NULL;

    if (nodePtr->level == 0) {
	prevLinePtr = NULL;
	linePtr = nodePtr->linePtr;
	for (linePtr = nodePtr->linePtr;
		numChildren < (int)nodePtr->numChildren;
		++numChildren, ++numLines, linePtr = linePtr->nextPtr) {
	    if (!linePtr) {
		Tcl_Panic("CheckNodeConsistency: unexpected end of line chain");
	    }
	    if (linePtr->parentPtr != nodePtr) {
		Tcl_Panic("CheckNodeConsistency: line has wrong parent pointer");
	    }
	    CheckSegments(sharedTextPtr, linePtr);
	    CheckSegmentItems(sharedTextPtr, linePtr);
	    CheckSections(linePtr);
	    for (i = 0; i < (int)references; ++i) {
		pixelInfo[i].pixels += linePtr->pixelInfo[i].height;
		pixelInfo[i].numDispLines += GetDisplayLines(linePtr, i);
	    }
	    if (tagonPtr) {
		tagonPtr = TkTextTagSetJoin(tagonPtr, linePtr->tagonPtr);
		tagoffPtr = TkTextTagSetJoin(tagoffPtr, linePtr->tagoffPtr);
		if (additionalTagoffPtr) {

		tagoffPtr = TkTextTagSetJoin(tagoffPtr, nodePtr->tagoffPtr);
		if (additionalTagoffPtr) {
		    additionalTagoffPtr = TkTextTagSetIntersect(additionalTagoffPtr, nodePtr->tagonPtr);
		} else {
		    TkTextTagSetIncrRefCount(additionalTagoffPtr = nodePtr->tagonPtr);
		}
	    }
	    for (i = 0; i < (int)references; i++) {
		pixelInfo[i].pixels += childNodePtr->pixelInfo[i].pixels;
		pixelInfo[i].numDispLines += childNodePtr->pixelInfo[i].numDispLines;
	    }
	}
    }
    if (size != nodePtr->size) {
	Tcl_Panic("CheckNodeConsistency: sum of size (%d) at level %d is wrong (%d is expected)",

	    }
	}

	TkTextTagSetDecrRefCount(tagonPtr);
	TkTextTagSetDecrRefCount(tagoffPtr);
	TkTextTagSetDecrRefCount(additionalTagoffPtr);
    }
    for (i = 0; i < (int)references; i++) {
	if (pixelInfo[i].pixels != nodePtr->pixelInfo[i].pixels) {
	    Tcl_Panic("CheckNodeConsistency: mismatch in pixel count "
		    "(expected: %d, counted: %d) for widget (%d) at level %d",
		    pixelInfo[i].pixels, nodePtr->pixelInfo[i].pixels, i, nodePtr->level);
	}
	if (pixelInfo[i].numDispLines != nodePtr->pixelInfo[i].numDispLines) {
	    Tcl_Panic("CheckNodeConsistency: mismatch in number of display lines "

    int lineNo, numLines;
    unsigned numDispLines;
    unsigned ref;

    assert(textPtr);
    assert(linePtr->logicalLine || linePtr == TkBTreeGetStartLine(textPtr));
    assert(*displayLineNo >= 0);
    assert(*displayLineNo < (int)GetDisplayLines(linePtr, textPtr->pixelReference));

    if (offset == 0) {
	return linePtr;
    }

    ref = textPtr->pixelReference;
    nodePtr = linePtr->parentPtr;

    unsigned ref;
    unsigned idx;
    int lineNo;

    assert(textPtr);
    assert(linePtr->logicalLine || linePtr == TkBTreeGetStartLine(textPtr));
    assert(*displayLineNo >= 0);
    assert(*displayLineNo < (int)GetDisplayLines(linePtr, textPtr->pixelReference));

    if (offset == 0) {
	return linePtr;
    }

    ref = textPtr->pixelReference;
    nodePtr = linePtr->parentPtr;

    }

    if (textPtr) {
	const TkSharedText *sharedTextPtr = treePtr->sharedTextPtr;

	if (textPtr->startMarker != sharedTextPtr->startMarker) {
	    if (linePtr1 == textPtr->startMarker->sectionPtr->linePtr) {
		assert(TkTextSegToIndex(textPtr->startMarker) <= (int)numBytes);
		numBytes -= TkTextSegToIndex(textPtr->startMarker);
	    }
	}
	if (textPtr->endMarker != sharedTextPtr->endMarker) {
	    if (!SegIsAtStartOfLine(textPtr->endMarker)) {
		const TkTextLine *linePtr = textPtr->endMarker->sectionPtr->linePtr;
		assert(linePtr->size - TkTextSegToIndex(textPtr->endMarker) - 1 <= (int)numBytes);
		numBytes -= linePtr->size - TkTextSegToIndex(textPtr->endMarker) - 1;
	    }
	}
    }

    return numBytes;
}

    /*
     * We couldn't find a line, so search inside B-Tree for next level-0
     * node which contains the byte offset.
     */

    while (parentPtr) {
	if (!nodePtr || (!HasLeftNode(nodePtr) && byteIndex >= (int)parentPtr->size)) {
	    nodePtr = parentPtr->nextPtr;
	    parentPtr = parentPtr->parentPtr;
	} else {
	    while (nodePtr) {
		if (byteIndex < (int)nodePtr->size) {
		    if (nodePtr->level > 0) {
			nodePtr = nodePtr->childPtr;
			continue;
		    }
		    /*
		     * We've found the right node, now search for the line.
		     */

    for (nPtr = parentPtr->childPtr, idx = 0; nPtr != nodePtr; nPtr = nPtr->nextPtr) {
	nodeStack[idx++] = nPtr;
    }
    nodePtr = idx ? nodeStack[--idx] : NULL;

    while (parentPtr) {
	if (!nodePtr || (!nodePtr->nextPtr && byteIndex >= (int)parentPtr->size)) {
	    nodePtr = parentPtr;
	    if ((parentPtr = parentPtr->parentPtr)) {
		for (nPtr = parentPtr->childPtr, idx = 0; nPtr != nodePtr; nPtr = nPtr->nextPtr) {
		    nodeStack[idx++] = nPtr;
		}
		nodePtr = idx ? nodeStack[--idx] : NULL;
	    }
	} else {
	    while (nodePtr) {
		if (byteIndex < (int)nodePtr->size) {
		    if (nodePtr->level > 0) {
			parentPtr = nodePtr;
			idx = 0;
			for (nPtr = nodePtr->childPtr; nPtr; nPtr = nPtr->nextPtr) {
			    nodeStack[idx++] = nPtr;
			}
			nodePtr = idx ? nodeStack[--idx] : NULL;

!if $(HAVE_UXTHEME_H)
		 -DHAVE_UXTHEME_H=1 \
!endif
!if $(TTK_SQUARE_WIDGET)
		 -DTTK_SQUARE_WIDGET=1 \
!endif

TK_DEFINES	=-DBUILD_ttk $(OPTDEFINES)  $(CONFIG_DEFS) -Dinline=__inline -DMODULE_SCOPE=""

#---------------------------------------------------------------------
# Compile flags
#---------------------------------------------------------------------

!if !$(DEBUG)
!if $(OPTIMIZING)