Tk Source Code

.
Include information about tags in the result. If additionally option
\fB\-nested\fR is specified, then two tag sets will be provided: firstly all
the tags starting with this content, and secondly all the tags ending after
this content (similar to the \fItagon\fR and \fItagoff\fR ranges in the
\fBdump\fR format). Without the \fB\-nested\fR option (this is the default) only
one list will be provided, namely all the tags associated to this segment
content. The tag list will be written in decreasing order, sorted by the
priority of the tag.
.TP
\fB\-text\fR
.
Include information about text (characters) in the dump result. The content
of this segment is the text up to the next segment. The segmentation of text
depends on the tagging information, any change in tagging is starting a new
segment. Note that soft hyphens (Unicode point U+00AD) do not belong to this

/*
 * Support of tk8.6/8.5.
 */
#ifndef DEF_TEXT_INACTIVE_SELECT_FG_COLOR
# if defined(MAC_OSX_TK)
#  define DEF_TEXT_INACTIVE_SELECT_FG_COLOR "systemDialogActiveText"
# elif defined(_WIN32)
#  define DEF_TEXT_INACTIVE_SELECT_FG_COLOR "SystemWindowText"
# else /* X11 */
#  define DEF_TEXT_INACTIVE_SELECT_FG_COLOR BLACK
# endif
# define DEF_TEXT_INACTIVE_SELECT_BG_COLOR DEF_TEXT_INACTIVE_SELECT_COLOR
#endif

/*

    {TK_OPTION_COLOR, "-hyphencolor", "hyphenColor", "HyphenColor",
	DEF_TEXT_FG, -1, Tk_Offset(TkText, hyphenColor), TK_OPTION_NULL_OK, 0, TK_TEXT_LINE_REDRAW},
    {TK_OPTION_BOOLEAN, "-hyphens", "hyphens", "Hyphens",
	"0", -1, Tk_Offset(TkText, useHyphenSupport), 0, 0, TK_TEXT_LINE_GEOMETRY},
    {TK_OPTION_BORDER, "-inactiveselectbackground", "inactiveSelectBackground", "Foreground",
	DEF_TEXT_INACTIVE_SELECT_BG_COLOR, -1, Tk_Offset(TkText, inactiveSelBorder),
	TK_OPTION_NULL_OK, DEF_TEXT_SELECT_MONO, 0},
    {TK_OPTION_COLOR, "-inactiveselectforeground", "inactiveSelectForeground",
	"Background", DEF_TEXT_INACTIVE_SELECT_FG_COLOR, -1,
	Tk_Offset(TkText, inactiveSelFgColorPtr), TK_OPTION_NULL_OK, DEF_TEXT_SELECT_FG_MONO, 0},
    {TK_OPTION_BORDER, "-insertbackground", "insertBackground", "Foreground",
	DEF_TEXT_INSERT_BG, -1, Tk_Offset(TkText, insertBorder), 0, 0, 0},
    {TK_OPTION_PIXELS, "-insertborderwidth", "insertBorderWidth",
	"BorderWidth", DEF_TEXT_INSERT_BD_COLOR, -1, Tk_Offset(TkText, insertBorderWidth), 0,
	(ClientData) DEF_TEXT_INSERT_BD_MONO, 0},
    {TK_OPTION_COLOR, "-insertforeground", "insertForeground", "InsertForeground",
	DEF_TEXT_BG_COLOR, -1, Tk_Offset(TkText, insertFgColorPtr), 0, 0, 0},

    }
    tree = textPtr->sharedTextPtr->tree;
    textPtr->sharedTextPtr->inspectEpoch += 1;
    lineno = TkBTreeLinesTo(tree, textPtr, TkTextIndexGetLine(&index1), NULL);
    prevByteIndex = index1;
    if (TkTextIndexBackBytes(textPtr, &index1, 1, &prevByteIndex) == 0) {
	unsigned epoch = textPtr->sharedTextPtr->inspectEpoch + 1;
	tagPtr = TkBTreeGetTags(&prevByteIndex);
	for (tPtr = tagPtr; tPtr; tPtr = tPtr->nextPtr) { tPtr->epoch = epoch; }
    } else {
	tagPtr = NULL;
    }
    if (TkTextIndexGetLine(&index1) == TkTextIndexGetLine(&index2)) {
	/* we are at the end, so we can ignore the return code of DumpLine */
	DumpLine(interp, textPtr, what, TkTextIndexGetLine(&index1),

	unsigned epoch = sharedTextPtr->inspectEpoch;

	TkTextIndexClear(&index, textPtr);
	TkTextIndexSetByteIndex2(&index, linePtr, startByte);
	TkBTreeMoveBackward(&index, 1);
	segPtr = TkTextIndexGetContentSegment(&index, NULL);
	assert(segPtr);
	tagPtr = TkBTreeGetSegmentTags(textPtr->sharedTextPtr, segPtr, textPtr, NULL);
	for (tPtr = tagPtr; tPtr; tPtr = tPtr->nextPtr) {
	    tPtr->flag = epoch; /* mark as open */
	}
    }

    /*
     * Must loop through line looking at its segments: character, hyphen, mark, image, window.

    }

    while (segPtr && offset < endByte) {
	currentSize = segPtr->size;

	if (offset + MAX(1, currentSize) > startByte) {
	    if ((what & TK_DUMP_TAG) && segPtr->tagInfoPtr) {
		TkTextTag *tagPtr = TkBTreeGetSegmentTags(sharedTextPtr, segPtr, textPtr, NULL);

		unsigned epoch = sharedTextPtr->inspectEpoch;
		unsigned nextEpoch = epoch + 1;
		TkTextTag *tPtr;

		for (tPtr = tagPtr; tPtr; tPtr = tPtr->nextPtr) {
		    if (tPtr->flag == epoch) {
			tPtr->flag = nextEpoch; /* mark as still open */

	    if (segPtr == textPtr->endMarker) {
		if (prevPtr != segPtr
		    	&& (what & SEG_GROUP_CHAR)
			&& segPtr->sectionPtr->linePtr != TkBTreeGetLastLine(textPtr)) {
		    /* print newline before finishing */
		    type = "break";
		    printTags = !!(what & TK_DUMP_TAG);
		    tagPtr = TkBTreeGetSegmentTags(sharedTextPtr,
			    segPtr->sectionPtr->linePtr->lastPtr, textPtr, NULL);
		    nextPtr = segPtr; /* repeat this mark */
		} else {
		    nextPtr = NULL; /* finished */
		}
	    } else if (!(what & SEG_GROUP_MARK)) {
		continue;
	    } else if (!TkTextIsNormalMark(segPtr)

		if (prevPtr == segPtr || *segPtr->body.chars == '\n') {
		    type = "break";
		    nextPtr = segPtr->sectionPtr->linePtr->nextPtr->segPtr;
		    if (prevPtr == segPtr) {
			tagPtr = prevTagPtr;
			segPtr->body.chars[segPtr->size - 1] = '\n';
		    } else if (type && printTags) {
			tagPtr = TkBTreeGetSegmentTags(sharedTextPtr, segPtr, textPtr, NULL);

		    }
		} else {
		    type = "text";
		    if (segPtr->size > 1 && segPtr->body.chars[segPtr->size - 1] == '\n') {
			nextPtr = segPtr; /* repeat this char segment */
			segPtr->body.chars[segPtr->size - 1] = '\0';
		    }
		    value = segPtr->body.chars;
		    if (printTags) {
			tagPtr = TkBTreeGetSegmentTags(sharedTextPtr, segPtr, textPtr, NULL);

		    }
		}
	    } else if (!nextPtr) {
		nextPtr = segPtr->sectionPtr->linePtr->nextPtr->segPtr;
	    }
	    break;
	default:

			}
			tagArray[numTags++] = prevTagPtr;
			prevTagPtr->flag = 0; /* mark as closed */
		    }
		}

		Tcl_DStringStartSublist(str);
		TkTextSortTags(numTags, tagArray);
		for (i = 0; i < numTags; ++i) {
		    Tcl_DStringAppendElement(str, tagArray[i]->name);
		}
		Tcl_DStringEndSublist(str);
	    }

	    prevTagPtr = NULL;

			    tagArray = realloc(tagArray, tagArrSize * sizeof(tagArray[0]));
			}
			tagArray[numTags++] = tPtr;
		    }
		}

		Tcl_DStringStartSublist(str);
		TkTextSortTags(numTags, tagArray);
		for (i = 0; i < numTags; ++i) {
		    Tcl_DStringAppendElement(str, tagArray[i]->name);
		}
		Tcl_DStringEndSublist(str);
	    }
	}

		    TkTextPrintIndex(tPtr, &index[1], idx[1]);

		    Tcl_DStringInit(&buf);
		    Tcl_DStringAppendElement(&buf, string);

		    tagPtr = NULL;
		    if (TkTextIndexBackChars(tPtr, &index[0], 1, &myIndex, COUNT_CHARS)) {
			tagPtr = TkBTreeGetTags(&myIndex);
		    }
		    AppendTags(&buf, tagPtr);
		    AppendTags(&buf, TkBTreeGetTags(&index[1]));
		    AppendTags(&buf, cmp == 0 ? NULL : TkBTreeGetTags(&index[0]));

		    if (*operation == 'd') {
			tagPtr = NULL;
			if (cmp && TkTextIndexBackChars(tPtr, &index[1], 1, &myIndex, COUNT_CHARS)) {
			    tagPtr = TkBTreeGetTags(&myIndex);
			}
			AppendTags(&buf, tagPtr);
		    }
		    Tcl_DStringAppendElement(&buf, final ? "yes" : "no");
		    arg = Tcl_DStringValue(&buf);

		    if (!TkTextTriggerWatchCmd(tPtr, operation, idx[0], idx[1],

extern int		TkBTreeGetNumberOfDisplayLines(const TkTextPixelInfo *pixelInfo);
extern TkTextPixelInfo *TkBTreeLinePixelInfo(const TkText *textPtr, TkTextLine *linePtr);
extern unsigned		TkBTreeEpoch(TkTextBTree tree);
extern unsigned		TkBTreeIncrEpoch(TkTextBTree tree);
extern struct Node	*TkBTreeGetRoot(TkTextBTree tree);
extern TkTextLine *	TkBTreePrevLogicalLine(const TkSharedText *sharedTextPtr,
			    const TkText *textPtr, TkTextLine *linePtr);
extern TkTextTag *	TkBTreeGetTags(const TkTextIndex *indexPtr);

extern TkTextLine *	TkBTreeGetStartLine(const TkText *textPtr);
extern TkTextLine *	TkBTreeGetLastLine(const TkText *textPtr);
extern TkTextLine *	TkBTreeNextLine(const TkText *textPtr, TkTextLine *linePtr);
extern TkTextLine *	TkBTreePrevLine(const TkText *textPtr, TkTextLine *linePtr);
extern unsigned		TkBTreeCountLines(const TkTextBTree tree, const TkTextLine *linePtr1,
			    const TkTextLine *linePtr2);
extern bool		TkTextGetIndexFromObj(Tcl_Interp *interp, TkText *textPtr, Tcl_Obj *objPtr,

#define TREE_GONE		(1 << 0)
#define DELETE_BRANCHES		(1 << 1)
#define DELETE_MARKS		(1 << 2)
#define DELETE_INCLUSIVE	(1 << 3)
#define DELETE_CLEANUP		(1 << 4)
#define DELETE_LASTLINE		(1 << 5)

















/*
 * The following definition specifies the maximum number of characters needed
 * in a string to hold a position specifier.
 */

#define TK_POS_CHARS		30

			    unsigned *displayLineNo, unsigned offset);
MODULE_SCOPE TkTextLine * TkBTreePrevDisplayLine(TkText *textPtr, TkTextLine *linePtr,
			    unsigned *displayLineNo, unsigned offset);
MODULE_SCOPE TkTextSegment * TkBTreeFindStartOfElidedRange(const TkSharedText *sharedTextPtr,
			    const TkText *textPtr, const TkTextSegment *segPtr);
MODULE_SCOPE TkTextSegment * TkBTreeFindEndOfElidedRange(const TkSharedText *sharedTextPtr,
			    const TkText *textPtr, const TkTextSegment *segPtr);
inline TkTextTag *	TkBTreeGetTags(const TkTextIndex *indexPtr);

MODULE_SCOPE TkTextTag * TkBTreeGetSegmentTags(const TkSharedText *sharedTextPtr,
			    const TkTextSegment *segPtr, const TkText *textPtr, bool *containsSelection);

MODULE_SCOPE const char * TkBTreeGetLang(const TkText *textPtr, const TkTextSegment *segPtr);
MODULE_SCOPE void	TkBTreeInsertChars(TkTextBTree tree, TkTextIndex *indexPtr, const char *string,
			    union TkTextTagSet *tagInfoPtr, TkTextTag *hyphenTagPtr,
			    TkTextUndoInfo *undoInfo);
MODULE_SCOPE TkTextSegment *TkBTreeMakeCharSegment(const char *string, unsigned length,
			    union TkTextTagSet *tagInfoPtr);
MODULE_SCOPE void	TkBTreeMakeUndoIndex(const TkSharedText *sharedTextPtr,

 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

static bool
TestIfElided(
    const TkTextTag *tagPtr)
{
    int highestPriority = -1;
    bool elide = false;

    for ( ; tagPtr; tagPtr = tagPtr->nextPtr) {
	if (tagPtr->elideString && (int) tagPtr->priority > highestPriority) {
	    elide = tagPtr->elide;
	    highestPriority = tagPtr->priority;
	}
    }

    return elide;
}

bool
TkTextIsElided(
    const TkTextIndex *indexPtr)/* The character in the text for which display information is wanted. */
{


    return TkBTreeGetRoot(indexPtr->tree)->numBranches > 0 && TestIfElided(TkBTreeGetTags(indexPtr));





}

/*
 *----------------------------------------------------------------------
 *
 * SegmentIsElided --
 *

static bool
SegmentIsElided(
    const TkSharedText *sharedTextPtr,
    const TkTextSegment *segPtr,
    const TkText *textPtr)		/* can be NULL */
{


    assert(segPtr->tagInfoPtr);

    return TkTextTagSetIntersectsBits(segPtr->tagInfoPtr, sharedTextPtr->elisionTags)



	    && TestIfElided(TkBTreeGetSegmentTags(sharedTextPtr, segPtr, textPtr, NULL));

}

/*
 *----------------------------------------------------------------------
 *
 * TkTextSegmentIsElided --
 *

TkTextTag *
TkBTreeGetSegmentTags(
    const TkSharedText *sharedTextPtr,	/* Handle to shared text resource. */
    const TkTextSegment *segPtr,	/* Get tags from this segment. */
    const TkText *textPtr,		/* If non-NULL, then only return tags for this text widget
    					 * (when there are peer widgets). */

    bool *containsSelection)		/* If non-NULL, return whether this chain contains the
    					 * "sel" tag. */

{
    const TkTextTagSet *tagInfoPtr;


    TkTextTag *chainPtr = NULL;




    assert(segPtr->tagInfoPtr);

    tagInfoPtr = segPtr->tagInfoPtr;

    if (containsSelection) {
	*containsSelection = false;
    }

    if (tagInfoPtr != sharedTextPtr->emptyTagInfoPtr) {
	unsigned i = TkTextTagSetFindFirst(tagInfoPtr);

	for ( ; i != TK_TEXT_TAG_SET_NPOS; i = TkTextTagSetFindNext(tagInfoPtr, i)) {
	    TkTextTag *tagPtr = sharedTextPtr->tagLookup[i];

	    assert(tagPtr);
	    assert(!tagPtr->isDisabled);

	    if (!textPtr || !tagPtr->textPtr) {
		tagPtr->nextPtr = chainPtr;
		tagPtr->epoch = 0;
		chainPtr = tagPtr;

	    } else if (tagPtr->textPtr == textPtr) {



		tagPtr->nextPtr = chainPtr;




		tagPtr->epoch = 0;






		chainPtr = tagPtr;



		if (tagPtr == textPtr->selTagPtr && containsSelection) {



		    *containsSelection = true;






		}
	    }






	}
    }











    return chainPtr;
}

/*
 *----------------------------------------------------------------------
 *
 * TkBTreeGetLang --
 *


/*
 *----------------------------------------------------------------------
 *
 * GetStyle --
 *
 *	This function creates all the information needed to display text at a
 *	particular location.

 *
 * Results:
 *	The return value is a pointer to a TextStyle structure that
 *	corresponds to *sValuePtr.
 *
 * Side effects:
 *	A new entry may be created in the style table for the widget.

    StyleValues styleValues;
    TextStyle *stylePtr;
    Tcl_HashEntry *hPtr;
    XGCValues gcValues;
    unsigned long mask;
    bool isNew;

    /*
     * The array below keeps track of the highest-priority specification
     * that has occurred for each of the various fields of the StyleValues.
     */

    enum {
	PRIO_BG_STIPPLE, PRIO_BORDER, PRIO_BORDER_WIDTH, PRIO_ELIDE, PRIO_EOL_COLOR, PRIO_FG,
	PRIO_FG_STIPPLE, PRIO_FONT, PRIO_HYPHEN_COLOR, PRIO_HYPHEN_RULES, PRIO_INDENT_BG,
	PRIO_JUSTIFY, PRIO_LANG, PRIO_LMARGIN_1, PRIO_LMARGIN_2, PRIO_LMARGIN_COLOR,
	PRIO_OFFSET, PRIO_OVERSTRIKE, PRIO_RELIEF, PRIO_RMARGIN, PRIO_RMARGIN_COLOR,
	PRIO_SPACING_1, PRIO_SPACING_2, PRIO_SPACING_3, PRIO_TAB, PRIO_TAB_STYLE,
	PRIO_UNDERLINE, PRIO_WRAP,
	PRIO_LAST /* must be last element */
    };

    int prio[PRIO_LAST] = {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1 };

    assert(prio[PRIO_LAST - 1] == -1);

    /*
     * Find out what tags are present for the character, then compute a
     * StyleValues structure corresponding to those tags (scan through all of
     * the tags, saving information for the highest-priority tag).
     */

    memset(&styleValues, 0, sizeof(StyleValues));

    styleValues.tabArrayPtr = textPtr->tabArrayPtr;
    styleValues.tabStyle = textPtr->tabStyle;
    styleValues.wrapMode = textPtr->wrapMode;
    styleValues.lang = textPtr->lang;
    styleValues.hyphenRules = textPtr->hyphenRulesPtr ? textPtr->hyphenRules : TK_TEXT_HYPHEN_MASK;

    for ( ; tagPtr; tagPtr = tagPtr->nextPtr) {
	Tk_3DBorder border;
        XColor *fgColor;
	int priority;

	border = tagPtr->border;
        fgColor = tagPtr->fgColor;
	priority = tagPtr->priority;

	/*
	 * If this is the selection tag, and inactiveSelBorder is NULL (the
	 * default on Windows), then we need to skip it if we don't have the
	 * focus.
	 */

	    }
	    if (tagPtr->selFgColor != None) {
		fgColor = tagPtr->selFgColor;
	    } else if (fgColor == None) {
		fgColor = textPtr->selFgColorPtr;
	    }
	}
	if (border && priority > prio[PRIO_BORDER]) {
	    styleValues.border = border;
	    prio[PRIO_BORDER] = priority;
	}
	if (tagPtr->borderWidthPtr
		&& Tcl_GetString(tagPtr->borderWidthPtr)[0] != '\0'
		&& priority > prio[PRIO_BORDER_WIDTH]) {
	    styleValues.borderWidth = tagPtr->borderWidth;
	    prio[PRIO_BORDER_WIDTH] = priority;
	}
	if (tagPtr->reliefPtr && priority > prio[PRIO_RELIEF]) {
	    if (!styleValues.border) {
		styleValues.border = textPtr->border;
	    }
	    assert(tagPtr->relief < 8);
	    styleValues.relief = tagPtr->relief;
	    prio[PRIO_RELIEF] = priority;
	}
	if (tagPtr->bgStipple != None && priority > prio[PRIO_BG_STIPPLE]) {
	    styleValues.bgStipple = tagPtr->bgStipple;
	    prio[PRIO_BG_STIPPLE] = priority;
	}
	if (tagPtr->indentBgString != None && priority > prio[PRIO_INDENT_BG]) {
	    styleValues.indentBg = tagPtr->indentBg;
	    prio[PRIO_INDENT_BG] = priority;
	}
	if (fgColor != None && priority > prio[PRIO_FG]) {
	    styleValues.fgColor = fgColor;
	    prio[PRIO_FG] = priority;
	}
	if (tagPtr->tkfont != None && priority > prio[PRIO_FONT]) {
	    styleValues.tkfont = tagPtr->tkfont;
	    prio[PRIO_FONT] = priority;
	}
	if (tagPtr->fgStipple != None && priority > prio[PRIO_FG_STIPPLE]) {
	    styleValues.fgStipple = tagPtr->fgStipple;
	    prio[PRIO_FG_STIPPLE] = priority;
	}
	if (tagPtr->justifyString && priority > prio[PRIO_JUSTIFY]) {
	    /* assert(tagPtr->justify < 8); always true due to range */
	    styleValues.justify = tagPtr->justify;
	    prio[PRIO_JUSTIFY] = priority;
	}
	if (tagPtr->lMargin1String && priority > prio[PRIO_LMARGIN_1]) {
	    styleValues.lMargin1 = tagPtr->lMargin1;
	    prio[PRIO_LMARGIN_1] = priority;
	}
	if (tagPtr->lMargin2String && priority > prio[PRIO_LMARGIN_2]) {
	    styleValues.lMargin2 = tagPtr->lMargin2;
	    prio[PRIO_LMARGIN_2] = priority;
	}
	if (tagPtr->lMarginColor && priority > prio[PRIO_LMARGIN_COLOR]) {
	    styleValues.lMarginColor = tagPtr->lMarginColor;
	    prio[PRIO_LMARGIN_COLOR] = priority;
	}
	if (tagPtr->offsetString && priority > prio[PRIO_OFFSET]) {
	    styleValues.offset = tagPtr->offset;
	    prio[PRIO_OFFSET] = priority;
	}
	if (tagPtr->overstrikeString && priority > prio[PRIO_OVERSTRIKE]) {
	    styleValues.overstrike = tagPtr->overstrike;
	    prio[PRIO_OVERSTRIKE] = priority;
            if (tagPtr->overstrikeColor != None) {
                 styleValues.overstrikeColor = tagPtr->overstrikeColor;
            } else if (fgColor != None) {
                 styleValues.overstrikeColor = fgColor;
            }
	}
	if (tagPtr->rMarginString && priority > prio[PRIO_RMARGIN]) {
	    styleValues.rMargin = tagPtr->rMargin;
	    prio[PRIO_RMARGIN] = priority;
	}
	if (tagPtr->rMarginColor && priority > prio[PRIO_RMARGIN_COLOR]) {
	    styleValues.rMarginColor = tagPtr->rMarginColor;
	    prio[PRIO_RMARGIN_COLOR] = priority;
	}
	if (tagPtr->spacing1String && priority > prio[PRIO_SPACING_1]) {
	    styleValues.spacing1 = tagPtr->spacing1;
	    prio[PRIO_SPACING_1] = priority;
	}
	if (tagPtr->spacing2String && priority > prio[PRIO_SPACING_2]) {
	    styleValues.spacing2 = tagPtr->spacing2;
	    prio[PRIO_SPACING_2] = priority;
	}
	if (tagPtr->spacing3String && priority > prio[PRIO_SPACING_3]) {
	    styleValues.spacing3 = tagPtr->spacing3;
	    prio[PRIO_SPACING_3] = priority;
	}
	if (tagPtr->tabStringPtr && priority > prio[PRIO_TAB]) {
	    styleValues.tabArrayPtr = tagPtr->tabArrayPtr;
	    prio[PRIO_TAB] = priority;
	}
	if (tagPtr->tabStyle != TK_TEXT_TABSTYLE_NONE && priority > prio[PRIO_TAB_STYLE]) {
	    assert(tagPtr->tabStyle < 8);
	    styleValues.tabStyle = tagPtr->tabStyle;
	    prio[PRIO_TAB_STYLE] = priority;
	}
	if (tagPtr->eolColor && priority > prio[PRIO_EOL_COLOR]) {
	    styleValues.eolColor = tagPtr->eolColor;
	    prio[PRIO_EOL_COLOR] = priority;
	}
	if (tagPtr->hyphenColor && priority > prio[PRIO_HYPHEN_COLOR]) {
	    styleValues.hyphenColor = tagPtr->hyphenColor;
	    prio[PRIO_HYPHEN_COLOR] = priority;
	}
	if (tagPtr->underlineString && priority > prio[PRIO_UNDERLINE]) {
	    styleValues.underline = tagPtr->underline;
	    prio[PRIO_UNDERLINE] = priority;
            if (tagPtr->underlineColor != None) {
		styleValues.underlineColor = tagPtr->underlineColor;
            } else if (fgColor != None) {
		styleValues.underlineColor = fgColor;
            }
	}
	if (tagPtr->elideString && priority > prio[PRIO_ELIDE]) {
	    styleValues.elide = tagPtr->elide;
	    prio[PRIO_ELIDE] = priority;
	}
	if (tagPtr->langPtr && priority > prio[PRIO_LANG]) {
	    styleValues.lang = tagPtr->lang;
	    prio[PRIO_LANG] = priority;
	}
	if (tagPtr->hyphenRulesPtr && priority > prio[PRIO_HYPHEN_RULES]) {
	    styleValues.hyphenRules = tagPtr->hyphenRules;
	    prio[PRIO_HYPHEN_RULES] = priority;
	}
	if (tagPtr->wrapMode != TEXT_WRAPMODE_NULL && priority > prio[PRIO_WRAP]) {
	    /* assert(tagPtr->wrapMode < 8); always true due to range */
	    styleValues.wrapMode = tagPtr->wrapMode;
	    prio[PRIO_WRAP] = priority;
	}
    }

    /*
     * Use an existing style if there's one around that matches.
     */

static TextStyle *
GetStyle(
    TkText *textPtr,		/* Overall information about text widget. */
    TkTextSegment *segPtr)	/* The text for which display information is wanted. */
{
    TextStyle *stylePtr;
    TkTextTag *tagPtr;
    bool containsSelection;

    if (segPtr && (tagPtr = TkBTreeGetSegmentTags(
		    textPtr->sharedTextPtr, segPtr, textPtr, &containsSelection))) {
	stylePtr = MakeStyle(textPtr, tagPtr, containsSelection);
    } else {
	/*
	 * Take into account that this function can be called before UpdateDefaultStyle
	 * has been called for the first time.
	 */
	if (!textPtr->dInfoPtr->defaultStyle) {
	    UpdateDefaultStyle(textPtr);

    } else {
	TkTextIndexBackChars(textPtr, newCursorIndexPtr, 1, &index, COUNT_INDICES);
    }

    numTags = 0;
    tagArrayPtr = tagArrayBuffer;
    tagArraySize = sizeof(tagArrayBuffer)/sizeof(tagArrayBuffer[0]);
    tagPtr = TkBTreeGetTags(&index);
    for ( ; tagPtr; tagPtr = tagPtr->nextPtr) {
	if (numTags == tagArraySize) {
	    tagArraySize *= 2;
	    tagArrayPtr = realloc(tagArrayPtr == tagArrayBuffer ? NULL : tagArrayPtr, tagArraySize);
	}
	tagArrayPtr[numTags++] = tagPtr;
    }
    TkTextSortTags(numTags, tagArrayPtr);
    for (i = 0; i < numTags; ++i) {
	Tcl_DStringAppendElement(&buf, tagArrayPtr[i]->name);
    }
    if (tagArrayPtr != tagArrayBuffer) {
	free(tagArrayPtr);
    }

 *
 *----------------------------------------------------------------------
 */

inline
TkTextTag *
TkBTreeGetTags(
    const TkTextIndex *indexPtr)/* Indicates a particular position in the B-tree. */


{
    const TkTextSegment *segPtr = TkTextIndexGetContentSegment(indexPtr, NULL);
    return TkBTreeGetSegmentTags(TkTextIndexGetShared(indexPtr), segPtr, indexPtr->textPtr, NULL);

}

/*
 *----------------------------------------------------------------------
 *
 * TkTextGetFirstChunkOfNextDispLine --
 *

TkTextFindTags(
    Tcl_Interp *interp,		/* Current interpreter. */
    TkText *textPtr,		/* Info about overall widget. */
    const TkTextSegment *segPtr,/* Tags from this segment. */
    bool discardSelection)	/* "sel" tag will be discarded? */
{
    TkTextTag *tagPtr;
    TkTextTag **tagArray;
    unsigned count;

    assert(segPtr);

    tagArray = malloc(textPtr->sharedTextPtr->numEnabledTags * sizeof(TkTextTag *));
    tagPtr = TkBTreeGetSegmentTags(textPtr->sharedTextPtr, segPtr, textPtr, NULL);



    for (count = 0; tagPtr; tagPtr = tagPtr->nextPtr) {
	if (!discardSelection || tagPtr != textPtr->selTagPtr) {
	    tagArray[count++] = tagPtr;
	}
    }

    AppendTags(interp, count, tagArray);
    free(tagArray);
}

/*
 *----------------------------------------------------------------------
 *
 * TkTextTagChangedUndoRedo --
 *

#define DEF_TEXT_INSERT_UNFOCUSSED	"none"
#define DEF_TEXT_INSERT_WIDTH		"2"
#define DEF_TEXT_MAX_UNDO		"0"
#define DEF_TEXT_PADX			"1"
#define DEF_TEXT_PADY			"1"
#define DEF_TEXT_RELIEF			"sunken"
#define DEF_TEXT_INACTIVE_SELECT_BG_COLOR NULL
#define DEF_TEXT_INACTIVE_SELECT_FG_COLOR TEXT_FG
#define DEF_TEXT_SELECT_COLOR		SELECT_BG
#define DEF_TEXT_SELECT_MONO		BLACK
#define DEF_TEXT_SELECT_BD_COLOR	"0"
#define DEF_TEXT_SELECT_BD_MONO		"0"
#define DEF_TEXT_SELECT_FG_COLOR	SELECT_FG
#define DEF_TEXT_SELECT_FG_MONO		WHITE
#define DEF_TEXT_SELECT_RELIEF		"flat"