Tk Source Code

	    }
	}

	gotTab = 0;
	maxBytes = segPtr->size - byteOffset;
	if (segPtr->typePtr == &tkTextCharType) {

            /*
             * See if there is a tab or soft hyphen in the current segment; if so,
             * only layout characters up to (and including) this character.
             */

            if (!elide) {
                char *p;

                for (p = segPtr->body.chars + byteOffset; *p != 0; p++) {
                    if (*p == '\u00AD') {
                        maxBytes = (p + 1 - segPtr->body.chars) - byteOffset;
                        break;
                    }
                }
            }
	    if (!elide && justify == TK_JUSTIFY_LEFT) {
		char *p;

		for (p = segPtr->body.chars + byteOffset; *p != 0; p++) {
		    if (*p == '\t') {
                        if ((p + 1 - segPtr->body.chars) - byteOffset <= maxBytes) {
                            maxBytes = (p + 1 - segPtr->body.chars) - byteOffset;
			    gotTab = 1;
			    break;
                        }
		    }
		}
	    }

#if TK_LAYOUT_WITH_BASE_CHUNKS
	    if (baseCharChunkPtr != NULL) {
		int expectedX =

     * Final update for the current base chunk data.
     */

    Tcl_DStringSetLength(baseString,lineOffset+ciPtr->numBytes);
    bciPtr->width = nextX - baseCharChunkPtr->x;

    /*
     * Finalize the base chunk if this chunk ends in a tab or soft hyphen,
     * which definitely breaks the context and needs to be handled on a
     * higher level.
     */

    if (ciPtr->numBytes > 0 && p[ciPtr->numBytes - 1] == '\t') {
	FinalizeBaseChunk(chunkPtr);
    } else if (ciPtr->numBytes > 1 && p[ciPtr->numBytes - 1] == '\u00AD') {
	FinalizeBaseChunk(chunkPtr);
    }
#endif /* TK_LAYOUT_WITH_BASE_CHUNKS */

    /*
     * Compute a break location. If we're in word wrap mode, a break can occur
     * after any space character, or at the end of the chunk if the next

	int start = ciPtr->baseOffset + offsetBytes;
	int len = ciPtr->numBytes - offsetBytes;
	int xDisplacement = x - chunkPtr->x;

	if ((len > 0) && (string[start + len - 1] == '\t')) {
	    len--;
	}

        /*
         * Don't draw any soft hyphen unless it is the last character
         * of the display line. Soft hyphens can only show up at the
         * end of a chunk, so test their presence at this place only.
         */

        if (chunkPtr->nextPtr != NULL) {
            if ((len > 1) && (string[start + len - 1] == '\u00AD')) {
                len = len - 2;
            }
        }

	if (len <= 0) {
	    return;
	}

	TkpDrawCharsInContext(display, dst, stylePtr->fgGC, sValuePtr->tkfont,
		string, numBytes, start, len,
		ciPtr->baseChunkPtr->x + xDisplacement,

#else /* !TK_DRAW_IN_CONTEXT */
	string += offsetBytes;
	numBytes -= offsetBytes;

	if ((numBytes > 0) && (string[numBytes - 1] == '\t')) {
	    numBytes--;
	}

        /*
         * Don't draw any soft hyphen unless it is the last character
         * of the display line. Soft hyphens can only show up at the
         * end of a chunk, so test their presence at this place only.
         */

        if (chunkPtr->nextPtr != NULL) {
            if ((numBytes > 1) && (string[numBytes - 1] == '\u00AD')) {
                numBytes = numBytes - 2;
            }
        }

	Tk_DrawChars(display, dst, stylePtr->fgGC, sValuePtr->tkfont, string,
		numBytes, offsetX, y + baseline - sValuePtr->offset);
	if (sValuePtr->underline) {
	    Tk_UnderlineChars(display, dst, stylePtr->ulGC, sValuePtr->tkfont,
		    string, offsetX,
		    y + baseline - sValuePtr->offset,
		    0, numBytes);

 * MeasureChars --
 *
 *	Determine the number of characters from the string that will fit in
 *	the given horizontal span. The measurement is done under the
 *	assumption that Tk_DrawChars will be used to actually display the
 *	characters.
 *
 *	If tabs or soft hyphens are encountered in the string, they will be
 *	ignored (they can only occur as last character of the string).
 *
 *	If a newline is encountered in the string, the line will be broken at
 *	that point.
 *
 * Results:
 *	The return value is the number of bytes from the range of start to end
 *	in source that fit in the span given by startX and maxX. *nextXPtr is

	     */

	    for (special = start; special < end; special++) {
		ch = *special;
		if ((ch == '\t') || (ch == '\n')) {
		    break;
		}
                if (ch == '\u00AD') {
                    special--;
                    break;
                }
	    }
	}

	/*
	 * Special points at the next special character (or the end of the
	 * string). Process characters between start and special.
	 */

	    /*
	     * No more chars fit in line.
	     */

	    break;
	}
	if (special < end) {
	    if (ch == '\n') {
		break;
	    }
            if (ch == '\u00AD') {
                start++;
            }
	    start++;
	}
    }

    *nextXPtr = curX;
    return start - (source+rangeStart);
}