Ck console graphics toolkit

[oss/ck.git] / ckTextDisp.c

/* 
 * ckTextDisp.c --
 *
 *      This module provides facilities to display text widgets.  It is
 *      the only place where information is kept about the screen layout
 *      of text widgets.
 *
 * Copyright (c) 1992-1994 The Regents of the University of California.
 * Copyright (c) 1994-1995 Sun Microsystems, Inc.
 * Copyright (c) 1995 Christian Werner
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

#include "ckPort.h"
#include "ck.h"
#include "ckText.h"

/*
 * The following structure describes how to display a range of characters.
 * The information is generated by scanning all of the tags associated
 * with the characters and combining that with default information for
 * the overall widget.  These structures form the hash keys for
 * dInfoPtr->styleTable.
 */

typedef struct StyleValues {
    int fg, bg, attr;
    int justify;                /* Justification style for text. */
    int lMargin1;               /* Left margin, in pixels, for first display
                                 * line of each text line. */
    int lMargin2;               /* Left margin, in pixels, for second and
                                 * later display lines of each text line. */
    int rMargin;                /* Right margin, in pixels. */
    CkTextTabArray *tabArrayPtr;/* Locations and types of tab stops (may
                                 * be NULL). */
    Ck_Uid wrapMode;            /* How to handle wrap-around for this tag.
                                 * One of ckTextCharUid, ckTextNoneUid,
                                 * or ckTextWordUid. */
} StyleValues;

/*
 * The following structure extends the StyleValues structure above with
 * graphics contexts used to actually draw the characters.  The entries
 * in dInfoPtr->styleTable point to structures of this type.
 */

typedef struct Style {
    int refCount;               /* Number of times this structure is
                                 * referenced in Chunks. */
    StyleValues *sValuePtr;     /* Raw information from which GCs were
                                 * derived. */
    Tcl_HashEntry *hPtr;        /* Pointer to entry in styleTable.  Used
                                 * to delete entry. */
} Style;

/*
 * The following macro determines whether two styles have the same
 * background so that, for example, no beveled border should be drawn
 * between them.
 */

#define SAME_BACKGROUND(s1, s2) \
    (((s1)->sValuePtr->border == (s2)->sValuePtr->border) \
        && ((s1)->sValuePtr->borderWidth == (s2)->sValuePtr->borderWidth) \
        && ((s1)->sValuePtr->relief == (s2)->sValuePtr->relief) \
        && ((s1)->sValuePtr->bgStipple == (s2)->sValuePtr->bgStipple))

/*
 * The following structure describes one line of the display, which may
 * be either part or all of one line of the text.
 */

typedef struct DLine {
    CkTextIndex index;          /* Identifies first character in text
                                 * that is displayed on this line. */
    int count;                  /* Number of characters accounted for by this
                                 * display line, including a trailing space
                                 * or newline that isn't actually displayed. */
    int y;                      /* Y-position at which line is supposed to
                                 * be drawn (topmost pixel of rectangular
                                 * area occupied by line). */
    int oldY;                   /* Y-position at which line currently
                                 * appears on display.  -1 means line isn't
                                 * currently visible on display and must be
                                 * redrawn.  This is used to move lines by
                                 * scrolling rather than re-drawing. */
    int height;                 /* Height of line, in chars. */
    int length;                 /* Total length of line, in chars. */
    CkTextDispChunk *chunkPtr;  /* Pointer to first chunk in list of all
                                 * of those that are displayed on this
                                 * line of the screen. */
    struct DLine *nextPtr;      /* Next in list of all display lines for
                                 * this window.   The list is sorted in
                                 * order from top to bottom.  Note:  the
                                 * next DLine doesn't always correspond
                                 * to the next line of text:  (a) can have
                                 * multiple DLines for one text line, and
                                 * (b) can have gaps where DLine's have been
                                 * deleted because they're out of date. */
    int flags;                  /* Various flag bits:  see below for values. */
} DLine;

/*
 * Flag bits for DLine structures:
 *
 * NEW_LAYOUT -                 Non-zero means that the line has been
 *                              re-layed out since the last time the
 *                              display was updated.
 * TOP_LINE -                   Non-zero means that this was the top line
 *                              in the window the last time that the window
 *                              was laid out.  This is important because
 *                              a line may be displayed differently if its
 *                              at the top or bottom than if it's in the
 *                              middle (e.g. beveled edges aren't displayed
 *                              for middle lines if the adjacent line has
 *                              a similar background).
 * BOTTOM_LINE -                Non-zero means that this was the bottom line
 *                              in the window the last time that the window
 *                              was laid out.
 */

#define NEW_LAYOUT      2
#define TOP_LINE        4
#define BOTTOM_LINE     8

/*
 * Overall display information for a text widget:
 */

typedef struct DInfo {
    Tcl_HashTable styleTable;   /* Hash table that maps from StyleValues
                                 * to Styles for this widget. */
    DLine *dLinePtr;            /* First in list of all display lines for
                                 * this widget, in order from top to bottom. */
    int x;                      /* First x-coordinate that may be used for
                                 * actually displaying line information.
                                 * Leaves space for border, etc. */
    int y;                      /* First y-coordinate that may be used for
                                 * actually displaying line information.
                                 * Leaves space for border, etc. */
    int maxX;                   /* First x-coordinate to right of available
                                 * space for displaying lines. */
    int maxY;                   /* First y-coordinate below available
                                 * space for displaying lines. */
    int topOfEof;               /* Top-most pixel (lowest y-value) that has
                                 * been drawn in the appropriate fashion for
                                 * the portion of the window after the last
                                 * line of the text.  This field is used to
                                 * figure out when to redraw part or all of
                                 * the eof field. */

    /*
     * Information used for scrolling:
     */

    int newCharOffset;          /* Desired x scroll position, measured as the
                                 * number of average-size characters off-screen
                                 * to the left for a line with no left
                                 * margin. */
    int curOffset;              /* Actual x scroll position, measured as the
                                 * number of chars off-screen to the left. */
    int maxLength;              /* Length in chars of longest line that's
                                 * visible in window (length may exceed window
                                 * size).  If there's no wrapping, this will
                                 * be zero. */
    double xScrollFirst, xScrollLast;
                                /* Most recent values reported to horizontal
                                 * scrollbar;  used to eliminate unnecessary
                                 * reports. */
    double yScrollFirst, yScrollLast;
                                /* Most recent values reported to vertical
                                 * scrollbar;  used to eliminate unnecessary
                                 * reports. */

    /*
     * Miscellaneous information:
     */

    int dLinesInvalidated;      /* This value is set to 1 whenever something
                                 * happens that invalidates information in
                                 * DLine structures;  if a redisplay
                                 * is in progress, it will see this and
                                 * abort the redisplay.  This is needed
                                 * because, for example, an embedded window
                                 * could change its size when it is first
                                 * displayed, invalidating the DLine that
                                 * is currently being displayed.  If redisplay
                                 * continues, it will use freed memory and
                                 * could dump core. */
    int flags;                  /* Various flag values:  see below for
                                 * definitions. */
} DInfo;

/*
 * In CkTextDispChunk structures for character segments, the clientData
 * field points to one of the following structures:
 */

typedef struct CharInfo {
    int numChars;               /* Number of characters to display. */
    CkWindow *winPtr;           /* For Ck_SetWindowAttr. */
    char chars[4];              /* Characters to display.  Actual size
                                 * will be numChars, not 4.  THIS MUST BE
                                 * THE LAST FIELD IN THE STRUCTURE. */
} CharInfo;

/*
 * Flag values for DInfo structures:
 *
 * DINFO_OUT_OF_DATE:           Non-zero means that the DLine structures
 *                              for this window are partially or completely
 *                              out of date and need to be recomputed.
 * REDRAW_PENDING:              Means that a when-idle handler has been
 *                              scheduled to update the display.
 * REDRAW_BORDERS:              Means window border or pad area has
 *                              potentially been damaged and must be redrawn.
 * REPICK_NEEDED:               1 means that the widget has been modified
 *                              in a way that could change the current
 *                              character (a different character might be
 *                              under the mouse cursor now).  Need to
 *                              recompute the current character before
 *                              the next redisplay.
 */

#define DINFO_OUT_OF_DATE       1
#define REDRAW_PENDING          2
#define REDRAW_BORDERS          4
#define REPICK_NEEDED           8

/*
 * The following counters keep statistics about redisplay that can be
 * checked to see how clever this code is at reducing redisplays.
 */

static int numRedisplays;       /* Number of calls to DisplayText. */
static int linesRedrawn;        /* Number of calls to DisplayDLine. */

/*
 * Forward declarations for procedures defined later in this file:
 */

static void             AdjustForTab _ANSI_ARGS_((CkText *textPtr,
                            CkTextTabArray *tabArrayPtr, int index,
                            CkTextDispChunk *chunkPtr));
static void             CharBboxProc _ANSI_ARGS_((CkTextDispChunk *chunkPtr,
                            int index, int y, int lineHeight, int baseline,
                            int *xPtr, int *yPtr, int *widthPtr,
                            int *heightPtr));
static void             CharDisplayProc _ANSI_ARGS_((CkTextDispChunk *chunkPtr,
                            int x, int y, int height, int baseline,
                            WINDOW *window, int screenY));
static int              CharMeasureProc _ANSI_ARGS_((CkTextDispChunk *chunkPtr,
                            int x));
static void             CharUndisplayProc _ANSI_ARGS_((CkText *textPtr,
                            CkTextDispChunk *chunkPtr));
static void             DisplayDLine _ANSI_ARGS_((CkText *textPtr,
                            DLine *dlPtr, DLine *prevPtr, WINDOW *window));
static void             DisplayText _ANSI_ARGS_((ClientData clientData));
static DLine *          FindDLine _ANSI_ARGS_((DLine *dlPtr,
                            CkTextIndex *indexPtr));
static void             FreeDLines _ANSI_ARGS_((CkText *textPtr,
                            DLine *firstPtr, DLine *lastPtr, int unlink));
static void             FreeStyle _ANSI_ARGS_((CkText *textPtr,
                            Style *stylePtr));
static Style *          GetStyle _ANSI_ARGS_((CkText *textPtr,
                            CkTextIndex *indexPtr));
static void             GetXView _ANSI_ARGS_((Tcl_Interp *interp,
                            CkText *textPtr, int report));
static void             GetYView _ANSI_ARGS_((Tcl_Interp *interp,
                            CkText *textPtr, int report));
static DLine *          LayoutDLine _ANSI_ARGS_((CkText *textPtr,
                            CkTextIndex *indexPtr));
static void             MeasureUp _ANSI_ARGS_((CkText *textPtr,
                            CkTextIndex *srcPtr, int distance,
                            CkTextIndex *dstPtr));
static void             UpdateDisplayInfo _ANSI_ARGS_((CkText *textPtr));
static void             ScrollByLines _ANSI_ARGS_((CkText *textPtr,
                            int offset));
static int              SizeOfTab _ANSI_ARGS_((CkText *textPtr,
                            CkTextTabArray *tabArrayPtr, int index, int x,
                            int maxX));
\f
/*
 *----------------------------------------------------------------------
 *
 * CkTextCreateDInfo --
 *
 *      This procedure is called when a new text widget is created.
 *      Its job is to set up display-related information for the widget.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      A DInfo data structure is allocated and initialized and attached
 *      to textPtr.
 *
 *----------------------------------------------------------------------
 */

void
CkTextCreateDInfo(textPtr)
    CkText *textPtr;            /* Overall information for text widget. */
{
    register DInfo *dInfoPtr;

    dInfoPtr = (DInfo *) ckalloc(sizeof(DInfo));
    Tcl_InitHashTable(&dInfoPtr->styleTable, sizeof(StyleValues)/sizeof(int));
    dInfoPtr->dLinePtr = NULL;
    dInfoPtr->topOfEof = 0;
    dInfoPtr->newCharOffset = 0;
    dInfoPtr->curOffset = 0;
    dInfoPtr->maxLength = 0;
    dInfoPtr->xScrollFirst = -1;
    dInfoPtr->xScrollLast = -1;
    dInfoPtr->yScrollFirst = -1;
    dInfoPtr->yScrollLast = -1;
    dInfoPtr->dLinesInvalidated = 0;
    dInfoPtr->flags = DINFO_OUT_OF_DATE;
    textPtr->dInfoPtr = dInfoPtr;
}
\f
/*
 *----------------------------------------------------------------------
 *
 * CkTextFreeDInfo --
 *
 *      This procedure is called to free up all of the private display
 *      information kept by this file for a text widget.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Lots of resources get freed.
 *
 *----------------------------------------------------------------------
 */

void
CkTextFreeDInfo(textPtr)
    CkText *textPtr;            /* Overall information for text widget. */
{
    register DInfo *dInfoPtr = textPtr->dInfoPtr;

    /*
     * Be careful to free up styleTable *after* freeing up all the
     * DLines, so that the hash table is still intact to free up the
     * style-related information from the lines.  Once the lines are
     * all free then styleTable will be empty.
     */

    FreeDLines(textPtr, dInfoPtr->dLinePtr, (DLine *) NULL, 1);
    Tcl_DeleteHashTable(&dInfoPtr->styleTable);
    if (dInfoPtr->flags & REDRAW_PENDING) {
        Tk_CancelIdleCall(DisplayText, (ClientData) textPtr);
    }
    ckfree((char *) dInfoPtr);
}
\f
/*
 *----------------------------------------------------------------------
 *
 * GetStyle --
 *
 *      This procedure creates all the information needed to display
 *      text at a particular location.
 *
 * Results:
 *      The return value is a pointer to a Style structure that
 *      corresponds to *sValuePtr.
 *
 * Side effects:
 *      A new entry may be created in the style table for the widget.
 *
 *----------------------------------------------------------------------
 */

static Style *
GetStyle(textPtr, indexPtr)
    CkText *textPtr;            /* Overall information about text widget. */
    CkTextIndex *indexPtr;      /* The character in the text for which
                                 * display information is wanted. */
{
    CkTextTag **tagPtrs;
    register CkTextTag *tagPtr;
    StyleValues styleValues;
    Style *stylePtr;
    Tcl_HashEntry *hPtr;
    int numTags, new, i;

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

    int bgPrio, fgPrio, attrPrio, justifyPrio;
    int lMargin1Prio, lMargin2Prio, rMarginPrio;
    int tabPrio, wrapPrio;

    /*
     * 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).
     */

    tagPtrs = CkBTreeGetTags(indexPtr, &numTags);
    bgPrio = fgPrio = attrPrio = justifyPrio = -1;
    lMargin1Prio = lMargin2Prio = rMarginPrio = -1;
    tabPrio = wrapPrio = -1;
    memset((VOID *) &styleValues, 0, sizeof(StyleValues));
    styleValues.fg = textPtr->fg;
    styleValues.bg = textPtr->bg;
    styleValues.attr = textPtr->attr;
    styleValues.justify = CK_JUSTIFY_LEFT;
    styleValues.tabArrayPtr = textPtr->tabArrayPtr;
    styleValues.wrapMode = textPtr->wrapMode;
    for (i = 0 ; i < numTags; i++) {
        tagPtr = tagPtrs[i];
        if ((tagPtr->bg != -1) && (tagPtr->priority > bgPrio)) {
            styleValues.bg = tagPtr->bg;
            bgPrio = tagPtr->priority;
        }
        if ((tagPtr->fg != -1) && (tagPtr->priority > fgPrio)) {
            styleValues.fg = tagPtr->fg;
            fgPrio = tagPtr->priority;
        }
        if ((tagPtr->attr != -1) && (tagPtr->priority > attrPrio)) {
            styleValues.attr = tagPtr->attr;
            attrPrio = tagPtr->priority;
        }
        if ((tagPtr->justifyString != NULL)
                && (tagPtr->priority > justifyPrio)) {
            styleValues.justify = tagPtr->justify;
            justifyPrio = tagPtr->priority;
        }
        if ((tagPtr->lMargin1String != NULL)
                && (tagPtr->priority > lMargin1Prio)) {
            styleValues.lMargin1 = tagPtr->lMargin1;
            lMargin1Prio = tagPtr->priority;
        }
        if ((tagPtr->lMargin2String != NULL)
                && (tagPtr->priority > lMargin2Prio)) {
            styleValues.lMargin2 = tagPtr->lMargin2;
            lMargin2Prio = tagPtr->priority;
        }
        if ((tagPtr->rMarginString != NULL)
                && (tagPtr->priority > rMarginPrio)) {
            styleValues.rMargin = tagPtr->rMargin;
            rMarginPrio = tagPtr->priority;
        }
        if ((tagPtr->tabString != NULL)
                && (tagPtr->priority > tabPrio)) {
            styleValues.tabArrayPtr = tagPtr->tabArrayPtr;
            tabPrio = tagPtr->priority;
        }
        if ((tagPtr->wrapMode != NULL)
                && (tagPtr->priority > wrapPrio)) {
            styleValues.wrapMode = tagPtr->wrapMode;
            wrapPrio = tagPtr->priority;
        }
    }
    if (tagPtrs != NULL) {
        ckfree((char *) tagPtrs);
    }

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

    hPtr = Tcl_CreateHashEntry(&textPtr->dInfoPtr->styleTable,
            (char *) &styleValues, &new);
    if (!new) {
        stylePtr = (Style *) Tcl_GetHashValue(hPtr);
        stylePtr->refCount++;
        return stylePtr;
    }

    /*
     * No existing style matched.  Make a new one.
     */

    stylePtr = (Style *) ckalloc(sizeof(Style));
    stylePtr->refCount = 1;
    stylePtr->sValuePtr = (StyleValues *)
            Tcl_GetHashKey(&textPtr->dInfoPtr->styleTable, hPtr);
    stylePtr->hPtr = hPtr;
    Tcl_SetHashValue(hPtr, stylePtr);
    return stylePtr;
}
\f
/*
 *----------------------------------------------------------------------
 *
 * FreeStyle --
 *
 *      This procedure is called when a Style structure is no longer
 *      needed.  It decrements the reference count and frees up the
 *      space for the style structure if the reference count is 0.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The storage and other resources associated with the style
 *      are freed up if no-one's still using it.
 *
 *----------------------------------------------------------------------
 */

static void
FreeStyle(textPtr, stylePtr)
    CkText *textPtr;            /* Information about overall widget. */
    register Style *stylePtr;   /* Information about style to be freed. */

{
    stylePtr->refCount--;
    if (stylePtr->refCount == 0) {
        Tcl_DeleteHashEntry(stylePtr->hPtr);
        ckfree((char *) stylePtr);
    }
}
\f
/*
 *----------------------------------------------------------------------
 *
 * LayoutDLine --
 *
 *      This procedure generates a single DLine structure for a display
 *      line whose leftmost character is given by indexPtr.
 *      
 * Results:
 *      The return value is a pointer to a DLine structure desribing the
 *      display line.  All fields are filled in and correct except for
 *      y and nextPtr.
 *
 * Side effects:
 *      Storage is allocated for the new DLine.
 *
 *----------------------------------------------------------------------
 */

static DLine *
LayoutDLine(textPtr, indexPtr)
    CkText *textPtr;            /* Overall information about text widget. */
    CkTextIndex *indexPtr;      /* Beginning of display line.  May not
                                 * necessarily point to a character segment. */
{
    register DLine *dlPtr;              /* New display line. */
    CkTextSegment *segPtr;              /* Current segment in text. */
    CkTextDispChunk *lastChunkPtr;      /* Last chunk allocated so far
                                         * for line. */
    CkTextDispChunk *chunkPtr;          /* Current chunk. */
    CkTextIndex curIndex;
    CkTextDispChunk *breakChunkPtr;     /* Chunk containing best word break
                                         * point, if any. */
    CkTextIndex breakIndex;             /* Index of first character in
                                         * breakChunkPtr. */
    int breakCharOffset;                /* Character within breakChunkPtr just
                                         * to right of best break point. */
    int noCharsYet;                     /* Non-zero means that no characters
                                         * have been placed on the line yet. */
    int justify;                        /* How to justify line: taken from
                                         * style for first character in line. */
    int jIndent;                        /* Additional indentation (beyond
                                         * margins) due to justification. */
    int rMargin;                        /* Right margin width for line. */
    Ck_Uid wrapMode;                    /* Wrap mode to use for this line. */
    int x = 0, maxX = 0;                /* Initializations needed only to
                                         * stop compiler warnings. */
    int wholeLine;                      /* Non-zero means this display line
                                         * runs to the end of the text line. */
    int tabIndex;                       /* Index of the current tab stop. */
    int gotTab;                         /* Non-zero means the current chunk
                                         * contains a tab. */
    CkTextDispChunk *tabChunkPtr;       /* Pointer to the chunk containing
                                         * the previous tab stop. */
    int maxChars;                       /* Maximum number of characters to
                                         * include in this chunk. */
    CkTextTabArray *tabArrayPtr;        /* Tab stops for line;  taken from
                                         * style for first character on line. */
    int tabSize;                        /* Number of pixels consumed by current
                                         * tab stop. */
    int offset, code;
    StyleValues *sValuePtr;

    /*
     * Create and initialize a new DLine structure.
     */

    dlPtr = (DLine *) ckalloc(sizeof(DLine));
    dlPtr->index = *indexPtr;
    dlPtr->count = 0;
    dlPtr->y = 0;
    dlPtr->oldY = -1;
    dlPtr->height = 0;
    dlPtr->chunkPtr = NULL;
    dlPtr->nextPtr = NULL;
    dlPtr->flags = NEW_LAYOUT;

    /*
     * Each iteration of the loop below creates one CkTextDispChunk for
     * the new display line.  The line will always have at least one
     * chunk (for the newline character at the end, if there's nothing
     * else available).
     */

    curIndex = *indexPtr;
    lastChunkPtr = NULL;
    chunkPtr = NULL;
    noCharsYet = 1;
    breakChunkPtr = NULL;
    breakCharOffset = 0;
    justify = CK_JUSTIFY_LEFT;
    tabIndex = -1;
    tabChunkPtr = NULL;
    tabArrayPtr = NULL;
    rMargin = 0;
    wrapMode = ckTextCharUid;
    tabSize = 0;

    /*
     * Find the first segment to consider for the line.  Can't call
     * CkTextIndexToSeg for this because it won't return a segment
     * with zero size (such as the insertion cursor's mark).
     */

    for (offset = curIndex.charIndex, segPtr = curIndex.linePtr->segPtr;
            (offset > 0) && (offset >= segPtr->size);
            offset -= segPtr->size, segPtr = segPtr->nextPtr) {
        /* Empty loop body. */
    }

    while (segPtr != NULL) {
        if (segPtr->typePtr->layoutProc == NULL) {
            segPtr = segPtr->nextPtr;
            offset = 0;
            continue;
        }
        if (chunkPtr == NULL) {
            chunkPtr = (CkTextDispChunk *) ckalloc(sizeof(CkTextDispChunk));
            chunkPtr->nextPtr = NULL;
        }
        chunkPtr->stylePtr = GetStyle(textPtr, &curIndex);

        /*
         * Save style information such as justification and indentation,
         * up until the first character is encountered, then retain that
         * information for the rest of the line.
         */

        if (noCharsYet) {
            tabArrayPtr = chunkPtr->stylePtr->sValuePtr->tabArrayPtr;
            justify = chunkPtr->stylePtr->sValuePtr->justify;
            rMargin = chunkPtr->stylePtr->sValuePtr->rMargin;
            wrapMode = chunkPtr->stylePtr->sValuePtr->wrapMode;
            x = ((curIndex.charIndex == 0)
                    ? chunkPtr->stylePtr->sValuePtr->lMargin1
                    : chunkPtr->stylePtr->sValuePtr->lMargin2);
            if (wrapMode == ckTextNoneUid) {
                maxX = INT_MAX;
            } else {
                maxX = textPtr->dInfoPtr->maxX - textPtr->dInfoPtr->x
                        - rMargin;
                if (maxX < x) {
                    maxX = x;
                }
            }
        }

        /*
         * See if there is a tab in the current chunk; if so, only
         * layout characters up to (and including) the tab.
         */

        gotTab = 0;
        maxChars = segPtr->size - offset;
        if (justify == CK_JUSTIFY_LEFT) {
            if (segPtr->typePtr == &ckTextCharType) {
                char *p;

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

        chunkPtr->x = x;
        code = (*segPtr->typePtr->layoutProc)(textPtr, &curIndex, segPtr,
                offset, maxX-tabSize, maxChars, noCharsYet, wrapMode,
                chunkPtr);
        if (code <= 0) {
            FreeStyle(textPtr, chunkPtr->stylePtr);
            if (code < 0) {
                /*
                 * This segment doesn't wish to display itself (e.g. most
                 * marks).
                 */

                segPtr = segPtr->nextPtr;
                offset = 0;
                continue;
            }

            /*
             * No characters from this segment fit in the window: this
             * means we're at the end of the display line.
             */

            if (chunkPtr != NULL) {
                ckfree((char *) chunkPtr);
            }
            break;
        }
        if (chunkPtr->numChars > 0) {
            noCharsYet = 0;
        }
        if (lastChunkPtr == NULL) {
            dlPtr->chunkPtr = chunkPtr;
        } else {
            lastChunkPtr->nextPtr = chunkPtr;
        }
        lastChunkPtr = chunkPtr;
        x += chunkPtr->width;
        if (chunkPtr->breakIndex > 0) {
            breakCharOffset = chunkPtr->breakIndex;
            breakIndex = curIndex;
            breakChunkPtr = chunkPtr;
        }
        if (chunkPtr->numChars != maxChars) {
            break;
        }

        /*
         * If we're at a new tab, adjust the layout for all the chunks
         * pertaining to the previous tab.  Also adjust the amount of
         * space left in the line to account for space that will be eaten
         * up by the tab.
         */

        if (gotTab) {
            if (tabIndex >= 0) {
                AdjustForTab(textPtr, tabArrayPtr, tabIndex, tabChunkPtr);
                x = chunkPtr->x + chunkPtr->width;
            }
            tabIndex++;
            tabChunkPtr = chunkPtr;
            tabSize = SizeOfTab(textPtr, tabArrayPtr, tabIndex, x, maxX);
            if (tabSize >= (maxX - x)) {
                break;
            }
        }
        curIndex.charIndex += chunkPtr->numChars;
        offset += chunkPtr->numChars;
        if (offset >= segPtr->size) {
            offset = 0;
            segPtr = segPtr->nextPtr;
        }
        chunkPtr = NULL;
    }
    if (noCharsYet) {
        panic("LayoutDLine couldn't place any characters on a line");
    }
    wholeLine = (segPtr == NULL);

    /*
     * We're at the end of the display line.  Throw away everything
     * after the most recent word break, if there is one;  this may
     * potentially require the last chunk to be layed out again.
     */

    if ((breakChunkPtr != NULL) && ((lastChunkPtr != breakChunkPtr)
            || (breakCharOffset != lastChunkPtr->numChars))) {
        while (1) {
            chunkPtr = breakChunkPtr->nextPtr;
            if (chunkPtr == NULL) {
                break;
            }
            FreeStyle(textPtr, chunkPtr->stylePtr);
            breakChunkPtr->nextPtr = chunkPtr->nextPtr;
            (*chunkPtr->undisplayProc)(textPtr, chunkPtr);
            ckfree((char *) chunkPtr);
        }
        if (breakCharOffset != breakChunkPtr->numChars) {
            (*breakChunkPtr->undisplayProc)(textPtr, breakChunkPtr);
            segPtr = CkTextIndexToSeg(&breakIndex, &offset);
            (*segPtr->typePtr->layoutProc)(textPtr, &breakIndex,
                    segPtr, offset, maxX, breakCharOffset, 0, 
                    wrapMode, breakChunkPtr);
        }
        lastChunkPtr = breakChunkPtr;
        wholeLine = 0;
    }

    /*
     * Make tab adjustments for the last tab stop, if there is one.
     */

    if ((tabIndex >= 0) && (tabChunkPtr != NULL)) {
        AdjustForTab(textPtr, tabArrayPtr, tabIndex, tabChunkPtr);
    }

    /*
     * Make one more pass over the line to recompute various things
     * like its height, length, and total number of characters.  Also
     * modify the x-locations of chunks to reflect justification.
     * If we're not wrapping, I'm not sure what is the best way to
     * handle left and center justification:  should the total length,
     * for purposes of justification, be (a) the window width, (b)
     * the length of the longest line in the window, or (c) the length
     * of the longest line in the text?  (c) isn't available, (b) seems
     * weird, since it can change with vertical scrolling, so (a) is
     * what is implemented below.
     */

    if (wrapMode == ckTextNoneUid) {
        maxX = textPtr->dInfoPtr->maxX - textPtr->dInfoPtr->x - rMargin;
    }
    dlPtr->length = lastChunkPtr->x + lastChunkPtr->width;
    if (justify == CK_JUSTIFY_LEFT) {
        jIndent = 0;
    } else if (justify == CK_JUSTIFY_RIGHT) {
        jIndent = maxX - dlPtr->length;
    } else {
        jIndent = (maxX - dlPtr->length)/2;
    }
    for (chunkPtr = dlPtr->chunkPtr; chunkPtr != NULL;
            chunkPtr = chunkPtr->nextPtr) {
        chunkPtr->x += jIndent;
        dlPtr->count += chunkPtr->numChars;
        if (chunkPtr->minHeight > dlPtr->height) {
            dlPtr->height = chunkPtr->minHeight;
        }
        sValuePtr = chunkPtr->stylePtr->sValuePtr;
    }
    sValuePtr = dlPtr->chunkPtr->stylePtr->sValuePtr;

    /*
     * Recompute line length:  may have changed because of justification.
     */

    dlPtr->length = lastChunkPtr->x + lastChunkPtr->width;
    return dlPtr;
}
\f
/*
 *----------------------------------------------------------------------
 *
 * UpdateDisplayInfo --
 *
 *      This procedure is invoked to recompute some or all of the
 *      DLine structures for a text widget.  At the time it is called
 *      the DLine structures still left in the widget are guaranteed
 *      to be correct except that (a) the y-coordinates aren't
 *      necessarily correct, (b) there may be missing structures
 *      (the DLine structures get removed as soon as they are potentially
 *      out-of-date), and (c) DLine structures that don't start at the
 *      beginning of a line may be incorrect if previous information in
 *      the same line changed size in a way that moved a line boundary
 *      (DLines for any info that changed will have been deleted, but
 *      not DLines for unchanged info in the same text line).
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Upon return, the DLine information for textPtr correctly reflects
 *      the positions where characters will be displayed.  However, this
 *      procedure doesn't actually bring the display up-to-date.
 *
 *----------------------------------------------------------------------
 */

static void
UpdateDisplayInfo(textPtr)
    CkText *textPtr;                    /* Text widget to update. */
{
    register DInfo *dInfoPtr = textPtr->dInfoPtr;
    register DLine *dlPtr, *prevPtr;
    CkTextIndex index;
    CkTextLine *lastLinePtr;
    int y, maxY, maxOffset;

    if (!(dInfoPtr->flags & DINFO_OUT_OF_DATE)) {
        return;
    }
    dInfoPtr->flags &= ~DINFO_OUT_OF_DATE;

    /*
     * Delete any DLines that are now above the top of the window.
     */

    index = textPtr->topIndex;
    dlPtr = FindDLine(dInfoPtr->dLinePtr, &index);
    if ((dlPtr != NULL) && (dlPtr != dInfoPtr->dLinePtr)) {
        FreeDLines(textPtr, dInfoPtr->dLinePtr, dlPtr, 1);
    }

    /*
     *--------------------------------------------------------------
     * Scan through the contents of the window from top to bottom,
     * recomputing information for lines that are missing.
     *--------------------------------------------------------------
     */

    lastLinePtr = CkBTreeFindLine(textPtr->tree,
            CkBTreeNumLines(textPtr->tree));
    dlPtr = dInfoPtr->dLinePtr;
    prevPtr = NULL;
    y = dInfoPtr->y;
    maxY = dInfoPtr->maxY;
    while (1) {
        register DLine *newPtr;

        if (index.linePtr == lastLinePtr) {
            break;
        }

        /*
         * There are three possibilities right now:
         * (a) the next DLine (dlPtr) corresponds exactly to the next
         *     information we want to display: just use it as-is.
         * (b) the next DLine corresponds to a different line, or to
         *     a segment that will be coming later in the same line:
         *     leave this DLine alone in the hopes that we'll be able
         *     to use it later, then create a new DLine in front of
         *     it.
         * (c) the next DLine corresponds to a segment in the line we
         *     want, but it's a segment that has already been processed
         *     or will never be processed.  Delete the DLine and try
         *     again.
         *
         * One other twist on all this.  It's possible for 3D borders
         * to interact between lines (see DisplayLineBackground) so if
         * a line is relayed out and has styles with 3D borders, its
         * neighbors have to be redrawn if they have 3D borders too,
         * since the interactions could have changed (the neighbors
         * don't have to be relayed out, just redrawn).
         */

        if ((dlPtr == NULL) || (dlPtr->index.linePtr != index.linePtr)) {
            /*
             * Case (b) -- must make new DLine.
             */

            makeNewDLine:
            if (ckTextDebug) {
                char string[TK_POS_CHARS];

                /*
                 * Debugging is enabled, so keep a log of all the lines
                 * that were re-layed out.  The test suite uses this
                 * information.
                 */

                CkTextPrintIndex(&index, string);
                Tcl_SetVar2(textPtr->interp, "ck_textRelayout", (char *) NULL,
                        string,
                        TCL_GLOBAL_ONLY|TCL_APPEND_VALUE|TCL_LIST_ELEMENT);
            }
            newPtr = LayoutDLine(textPtr, &index);
            if (prevPtr == NULL) {
                dInfoPtr->dLinePtr = newPtr;
            } else {
                prevPtr->nextPtr = newPtr;
            }
            newPtr->nextPtr = dlPtr;
            dlPtr = newPtr;
        } else {
            /*
             * DlPtr refers to the line we want.  Next check the
             * index within the line.
             */

            if (index.charIndex == dlPtr->index.charIndex) {
                /*
                 * Case (a) -- can use existing display line as-is.
                 */
                goto lineOK;
            }
            if (index.charIndex < dlPtr->index.charIndex) {
                goto makeNewDLine;
            }

            /*
             * Case (c) -- dlPtr is useless.  Discard it and start
             * again with the next display line.
             */

            newPtr = dlPtr->nextPtr;
            FreeDLines(textPtr, dlPtr, newPtr, 0);
            dlPtr = newPtr;
            continue;
        }

        /*
         * Advance to the start of the next line.
         */

        lineOK:
        dlPtr->y = y;
        y += dlPtr->height;
#if CK_USE_UTF
        CkTextIndexForwBytes(&index, dlPtr->count, &index);
#else
        CkTextIndexForwChars(&index, dlPtr->count, &index);
#endif
        prevPtr = dlPtr;
        dlPtr = dlPtr->nextPtr;

        /*
         * If we switched text lines, delete any DLines left for the
         * old text line.
         */

        if (index.linePtr != prevPtr->index.linePtr) {
            register DLine *nextPtr;

            nextPtr = dlPtr;
            while ((nextPtr != NULL)
                    && (nextPtr->index.linePtr == prevPtr->index.linePtr)) {
                nextPtr = nextPtr->nextPtr;
            }
            if (nextPtr != dlPtr) {
                FreeDLines(textPtr, dlPtr, nextPtr, 0);
                prevPtr->nextPtr = nextPtr;
                dlPtr = nextPtr;
            }
        }

        /*
         * It's important to have the following check here rather than in
         * the while statement for the loop, so that there's always at least
         * one DLine generated, regardless of how small the window is.  This
         * keeps a lot of other code from breaking.
         */

        if (y >= maxY) {
            break;
        }
    }

    /*
     * Delete any DLine structures that don't fit on the screen.
     */

    FreeDLines(textPtr, dlPtr, (DLine *) NULL, 1);

    /*
     *--------------------------------------------------------------
     * If there is extra space at the bottom of the window (because
     * we've hit the end of the text), then bring in more lines at
     * the top of the window, if there are any, to fill in the view.
     *--------------------------------------------------------------
     */

    if (y < maxY) {
        int lineNum, spaceLeft, charsToCount;
        DLine *lowestPtr;

        /*
         * Layout an entire text line (potentially > 1 display line),
         * then link in as many display lines as fit without moving
         * the bottom line out of the window.  Repeat this until
         * all the extra space has been used up or we've reached the
         * beginning of the text.
         */

        spaceLeft = maxY - y;
        lineNum = CkBTreeLineIndex(dInfoPtr->dLinePtr->index.linePtr);
        charsToCount = dInfoPtr->dLinePtr->index.charIndex;
        if (charsToCount == 0) {
            charsToCount = INT_MAX;
            lineNum--;
        }
        for ( ; (lineNum >= 0) && (spaceLeft > 0); lineNum--) {
            index.linePtr = CkBTreeFindLine(textPtr->tree, lineNum);
            index.charIndex = 0;
            lowestPtr = NULL;
            do {
                dlPtr = LayoutDLine(textPtr, &index);
                dlPtr->nextPtr = lowestPtr;
                lowestPtr = dlPtr;
#if CK_USE_UTF
                if (dlPtr->length == 0 && dlPtr->height == 0) {
                    charsToCount--;
                    break;
                }
                CkTextIndexForwBytes(&index, dlPtr->count, &index);
#else
                CkTextIndexForwChars(&index, dlPtr->count, &index);
#endif
                charsToCount -= dlPtr->count;
            } while ((charsToCount > 0)
                    && (index.linePtr == lowestPtr->index.linePtr));

            /*
             * Scan through the display lines from the bottom one up to
             * the top one.
             */

            while (lowestPtr != NULL) {
                dlPtr = lowestPtr;
                spaceLeft -= dlPtr->height;
                if (spaceLeft < 0) {
                    break;
                }
                lowestPtr = dlPtr->nextPtr;
                dlPtr->nextPtr = dInfoPtr->dLinePtr;
                dInfoPtr->dLinePtr = dlPtr;
                if (ckTextDebug) {
                    char string[TK_POS_CHARS];

                    CkTextPrintIndex(&dlPtr->index, string);
                    Tcl_SetVar2(textPtr->interp, "ck_textRelayout",
                            (char *) NULL, string,
                            TCL_GLOBAL_ONLY|TCL_APPEND_VALUE|TCL_LIST_ELEMENT);
                }
            }
            FreeDLines(textPtr, lowestPtr, (DLine *) NULL, 0);
            charsToCount = INT_MAX;
        }

        /*
         * Now we're all done except that the y-coordinates in all the
         * DLines are wrong and the top index for the text is wrong.
         * Update them.
         */

        textPtr->topIndex = dInfoPtr->dLinePtr->index;
        y = dInfoPtr->y;
        for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL;
                dlPtr = dlPtr->nextPtr) {
            if (y > dInfoPtr->maxY) {
                panic("Added too many new lines in UpdateDisplayInfo");
            }
            dlPtr->y = y;
            y += dlPtr->height; 
        }
    }

    /*
     *--------------------------------------------------------------
     * If the old top or bottom line has scrolled elsewhere on the
     * screen, we may not be able to re-use its old contents by
     * copying bits (e.g., a beveled edge that was drawn when it was
     * at the top or bottom won't be drawn when the line is in the
     * middle and its neighbor has a matching background).  Similarly,
     * if the new top or bottom line came from somewhere else on the
     * screen, we may not be able to copy the old bits.
     *--------------------------------------------------------------
     */

    dlPtr = dInfoPtr->dLinePtr;
    while (1) {
        if (dlPtr->nextPtr == NULL) {
            dlPtr->flags &= ~TOP_LINE;
            dlPtr->flags |= BOTTOM_LINE;
            break;
        }
        dlPtr->flags &= ~(TOP_LINE|BOTTOM_LINE);
        dlPtr = dlPtr->nextPtr;
    }
    dInfoPtr->dLinePtr->flags |= TOP_LINE;

    /*
     * Arrange for scrollbars to be updated.
     */

    textPtr->flags |= UPDATE_SCROLLBARS;

    /*
     *--------------------------------------------------------------
     * Deal with horizontal scrolling:
     * 1. If there's empty space to the right of the longest line,
     *    shift the screen to the right to fill in the empty space.
     * 2. If the desired horizontal scroll position has changed,
     *    force a full redisplay of all the lines in the widget.
     * 3. If the wrap mode isn't "none" then re-scroll to the base
     *    position.
     *--------------------------------------------------------------
     */

    dInfoPtr->maxLength = 0;
    for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL;
            dlPtr = dlPtr->nextPtr) {
        if (dlPtr->length > dInfoPtr->maxLength) {
            dInfoPtr->maxLength = dlPtr->length;
        }
    }

    maxOffset = dInfoPtr->maxLength - (dInfoPtr->maxX - dInfoPtr->x);
    if (dInfoPtr->newCharOffset >= maxOffset) {
        dInfoPtr->newCharOffset = maxOffset != 0 ? maxOffset + 1 : 0;
    }
    if (dInfoPtr->newCharOffset < 0) {
        dInfoPtr->newCharOffset = 0;
    }
    if (dInfoPtr->newCharOffset != dInfoPtr->curOffset) {
        dInfoPtr->curOffset = dInfoPtr->newCharOffset;
        for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL;
                dlPtr = dlPtr->nextPtr) {
            dlPtr->oldY = -1;
        }
    }
}
\f
/*
 *----------------------------------------------------------------------
 *
 * FreeDLines --
 *
 *      This procedure is called to free up all of the resources
 *      associated with one or more DLine structures.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Memory gets freed and various other resources are released.
 *
 *----------------------------------------------------------------------
 */

static void
FreeDLines(textPtr, firstPtr, lastPtr, unlink)
    CkText *textPtr;                    /* Information about overall text
                                         * widget. */
    register DLine *firstPtr;           /* Pointer to first DLine to free up. */
    DLine *lastPtr;                     /* Pointer to DLine just after last
                                         * one to free (NULL means everything
                                         * starting with firstPtr). */
    int unlink;                         /* 1 means DLines are currently linked
                                         * into the list rooted at
                                         * textPtr->dInfoPtr->dLinePtr and
                                         * they have to be unlinked.  0 means
                                         * just free without unlinking. */
{
    register CkTextDispChunk *chunkPtr, *nextChunkPtr;
    register DLine *nextDLinePtr;

    if (unlink) {
        if (textPtr->dInfoPtr->dLinePtr == firstPtr) {
            textPtr->dInfoPtr->dLinePtr = lastPtr;
        } else {
            register DLine *prevPtr;
            for (prevPtr = textPtr->dInfoPtr->dLinePtr;
                    prevPtr->nextPtr != firstPtr; prevPtr = prevPtr->nextPtr) {
                /* Empty loop body. */
            }
            prevPtr->nextPtr = lastPtr;
        }
    }
    while (firstPtr != lastPtr) {
        nextDLinePtr = firstPtr->nextPtr;
        for (chunkPtr = firstPtr->chunkPtr; chunkPtr != NULL;
                chunkPtr = nextChunkPtr) {
            if (chunkPtr->undisplayProc != NULL) {
                (*chunkPtr->undisplayProc)(textPtr, chunkPtr);
            }
            FreeStyle(textPtr, chunkPtr->stylePtr);
            nextChunkPtr = chunkPtr->nextPtr;
            ckfree((char *) chunkPtr);
        }
        ckfree((char *) firstPtr);
        firstPtr = nextDLinePtr;
    }
    textPtr->dInfoPtr->dLinesInvalidated = 1;
}
\f
/*
 *----------------------------------------------------------------------
 *
 * DisplayDLine --
 *
 *      This procedure is invoked to draw a single line on the
 *      screen.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The line given by dlPtr is drawn at its correct position in
 *      textPtr's window.  Note that this is one *display* line, not
 *      one *text* line.
 *
 *----------------------------------------------------------------------
 */

static void
DisplayDLine(textPtr, dlPtr, prevPtr, window)
    CkText *textPtr;            /* Text widget in which to draw line. */
    register DLine *dlPtr;      /* Information about line to draw. */
    DLine *prevPtr;             /* Line just before one to draw, or NULL
                                 * if dlPtr is the top line. */
    WINDOW *window;
{
    register CkTextDispChunk *chunkPtr;
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    int x;

    /*
     * First, clear the area of the line to the background color for the
     * text widget.
     */

    Ck_SetWindowAttr(textPtr->winPtr, textPtr->fg, textPtr->bg, textPtr->attr);
    Ck_ClearToEol(textPtr->winPtr, 0, dlPtr->y);

    /*
     * Make yet another pass through all of the chunks to redraw all of
     * foreground information.  Note:  we have to call the displayProc
     * even for chunks that are off-screen.  This is needed, for
     * example, so that embedded windows can be unmapped in this case.
     */

    for (chunkPtr = dlPtr->chunkPtr; (chunkPtr != NULL);
            chunkPtr = chunkPtr->nextPtr) {
        x = chunkPtr->x + dInfoPtr->x - dInfoPtr->curOffset;
        if (chunkPtr->displayProc == CkTextInsertDisplayProc) {
            (*chunkPtr->displayProc)(chunkPtr, x, 0, dlPtr->height,
                 0, window, dlPtr->y);
            continue;
        }
        if ((x + chunkPtr->width <= 0) || (x >= dInfoPtr->maxX)) {
            /*
             * Note:  we have to call the displayProc even for chunks
             * that are off-screen.  This is needed, for example, so
             * that embedded windows can be unmapped in this case.
             * Display the chunk at a coordinate that can be clearly
             * identified by the displayProc as being off-screen to
             * the left (the displayProc may not be able to tell if
             * something is off to the right).
             */

            (*chunkPtr->displayProc)(chunkPtr, -chunkPtr->width,
                    0, dlPtr->height, 0, window, dlPtr->y);
        } else {
            (*chunkPtr->displayProc)(chunkPtr, x, 0,
                    dlPtr->height, 0, window, dlPtr->y);
        }
        if (dInfoPtr->dLinesInvalidated) {
            return;
        }
    }
    linesRedrawn++;
}
\f
/*
 *----------------------------------------------------------------------
 *
 * DisplayText --
 *
 *      This procedure is invoked as a when-idle handler to update the
 *      display.  It only redisplays the parts of the text widget that
 *      are out of date.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Information is redrawn on the screen.
 *
 *----------------------------------------------------------------------
 */

static void
DisplayText(clientData)
    ClientData clientData;      /* Information about widget. */
{
    register CkText *textPtr = (CkText *) clientData;
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    CkWindow *winPtr;
    register DLine *dlPtr;
    DLine *prevPtr;
    int maxHeight;
    int bottomY = 0;            /* Initialization needed only to stop
                                 * compiler warnings. */

    if (textPtr->winPtr == NULL) {
        /*
         * The widget has been deleted.  Don't do anything.
         */

        return;
    }

    if (ckTextDebug) {
        Tcl_SetVar2(textPtr->interp, "ck_textRelayout", (char *) NULL,
                "", TCL_GLOBAL_ONLY);
    }

    if (!(textPtr->winPtr->flags & CK_MAPPED) ||
        (dInfoPtr->maxX <= dInfoPtr->x) || (dInfoPtr->maxY <= dInfoPtr->y)) {
        UpdateDisplayInfo(textPtr);
        dInfoPtr->flags &= ~REDRAW_PENDING;
        goto doScrollbars;
    }
    numRedisplays++;
    if (ckTextDebug) {
        Tcl_SetVar2(textPtr->interp, "ck_textRedraw", (char *) NULL,
                "", TCL_GLOBAL_ONLY);
    }

    /*
     * Choose a new current item if that is needed (this could cause
     * event handlers to be invoked, hence the preserve/release calls
     * and the loop, since the handlers could conceivably necessitate
     * yet another current item calculation).  The ckwin check is because
     * the whole window could go away in the Ck_Release call.
     */

    while (dInfoPtr->flags & REPICK_NEEDED) {
        Ck_Preserve((ClientData) textPtr);
        dInfoPtr->flags &= ~REPICK_NEEDED;
        CkTextPickCurrent(textPtr, &textPtr->pickEvent);
        winPtr = textPtr->winPtr;
        Ck_Release((ClientData) textPtr);
        if (winPtr == NULL) {
            return;
        }
    }

    /*
     * First recompute what's supposed to be displayed.
     */

    UpdateDisplayInfo(textPtr);
    dInfoPtr->dLinesInvalidated = 0;
    dInfoPtr->flags &= ~REDRAW_PENDING;

    maxHeight = -1;
    for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL; dlPtr = dlPtr->nextPtr) {
        if ((dlPtr->height > maxHeight) && (dlPtr->oldY != dlPtr->y)) {
            maxHeight = dlPtr->height;
        }
        bottomY = dlPtr->y + dlPtr->height;
    }
    if (maxHeight > dInfoPtr->maxY) {
        maxHeight = dInfoPtr->maxY;
    }


    /*
     * Now we have to redraw the lines that couldn't be updated by
     * scrolling.  First, compute the height of the largest line and
     * allocate an off-screen pixmap to use for double-buffered
     * displays.
     */

    if (maxHeight > 0) {
        for (prevPtr = NULL, dlPtr = textPtr->dInfoPtr->dLinePtr;
                (dlPtr != NULL) && (dlPtr->y < dInfoPtr->maxY);
                prevPtr = dlPtr, dlPtr = dlPtr->nextPtr) {
            if (dlPtr->oldY != dlPtr->y) {
                if (ckTextDebug) {
                    char string[TK_POS_CHARS];
                    CkTextPrintIndex(&dlPtr->index, string);
                    Tcl_SetVar2(textPtr->interp, "ck_textRedraw",
                            (char *) NULL, string,
                            TCL_GLOBAL_ONLY|TCL_APPEND_VALUE|TCL_LIST_ELEMENT);
                }
                DisplayDLine(textPtr, dlPtr, prevPtr, textPtr->winPtr->window);
                if (dInfoPtr->dLinesInvalidated) {
                    goto done;
                }
                dlPtr->oldY = dlPtr->y;
                dlPtr->flags &= ~NEW_LAYOUT;
            }
        }
    }

    /*
     * See if we need to refresh the part of the window below the
     * last line of text (if there is any such area).
     */

    if (dInfoPtr->topOfEof > dInfoPtr->maxY) {
        dInfoPtr->topOfEof = dInfoPtr->maxY;
    }
    if (bottomY < dInfoPtr->topOfEof) {
        if (ckTextDebug) {
            Tcl_SetVar2(textPtr->interp, "ck_textRedraw",
                    (char *) NULL, "eof",
                    TCL_GLOBAL_ONLY|TCL_APPEND_VALUE|TCL_LIST_ELEMENT);
        }
        Ck_SetWindowAttr(textPtr->winPtr, textPtr->fg, textPtr->bg,
            textPtr->attr);
        Ck_ClearToBot(textPtr->winPtr, 0, bottomY);
    }
    dInfoPtr->topOfEof = bottomY;

doScrollbars:

    /*
     * Update the vertical scrollbar, if there is one.  Note: it's
     * important to clear REDRAW_PENDING here, just in case the
     * scroll procedure does something that requires redisplay.
     */

    if (textPtr->flags & UPDATE_SCROLLBARS) {
        textPtr->flags &= ~UPDATE_SCROLLBARS;
        if (textPtr->yScrollCmd != NULL) {
            GetYView(textPtr->interp, textPtr, 1);
        }

        /*
         * Update the horizontal scrollbar, if any.
         */

        if (textPtr->xScrollCmd != NULL) {
            GetXView(textPtr->interp, textPtr, 1);
        }
    }
done:
    if (textPtr->insertX >= 0 &&
        textPtr->insertX < textPtr->winPtr->width &&
        textPtr->insertY >= 0 &&
        textPtr->insertY < textPtr->winPtr->height &&
        textPtr->winPtr->window != NULL) {
        wmove(textPtr->winPtr->window, textPtr->insertY, textPtr->insertX);
        Ck_SetHWCursor(textPtr->winPtr, 1);
    } else
        Ck_SetHWCursor(textPtr->winPtr, 0);
    Ck_EventuallyRefresh(textPtr->winPtr);
}
\f
/*
 *----------------------------------------------------------------------
 *
 * CkTextEventuallyRepick --
 *
 *      This procedure is invoked whenever something happens that
 *      could change the current character or the tags associated
 *      with it.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      A repick is scheduled as an idle handler.
 *
 *----------------------------------------------------------------------
 */

        /* ARGSUSED */
void
CkTextEventuallyRepick(textPtr)
    CkText *textPtr;            /* Widget record for text widget. */
{
    DInfo *dInfoPtr = textPtr->dInfoPtr;

    dInfoPtr->flags |= REPICK_NEEDED;
    if (!(dInfoPtr->flags & REDRAW_PENDING)) {
        dInfoPtr->flags |= REDRAW_PENDING;
        Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
    }
}
\f
/*
 *----------------------------------------------------------------------
 *
 * CkTextRedrawRegion --
 *
 *      This procedure is invoked to schedule a redisplay for a given
 *      region of a text widget.  The redisplay itself may not occur
 *      immediately:  it's scheduled as a when-idle handler.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Information will eventually be redrawn on the screen.
 *
 *----------------------------------------------------------------------
 */

        /* ARGSUSED */
void
CkTextRedrawRegion(textPtr, x, y, width, height)
    CkText *textPtr;            /* Widget record for text widget. */
    int x, y;                   /* Coordinates of upper-left corner of area
                                 * to be redrawn, in pixels relative to
                                 * textPtr's window. */
    int width, height;          /* Width and height of area to be redrawn. */
{
    register DLine *dlPtr;
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    int maxY;

    /*
     * Find all lines that overlap the given region and mark them for
     * redisplay.
     */

    maxY = y + height;
    for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL;
            dlPtr = dlPtr->nextPtr) {
        if (((dlPtr->y + dlPtr->height) > y) && (dlPtr->y < maxY)) {
            dlPtr->oldY = -1;
        }
    }
    if (dInfoPtr->topOfEof < maxY) {
        dInfoPtr->topOfEof = maxY;
    }

    /*
     * Schedule the redisplay operation if there isn't one already
     * scheduled.
     */

    if (!(dInfoPtr->flags & REDRAW_PENDING)) {
        dInfoPtr->flags |= REDRAW_PENDING;
        Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
    }
}
\f
/*
 *----------------------------------------------------------------------
 *
 * CkTextChanged --
 *
 *      This procedure is invoked when info in a text widget is about
 *      to be modified in a way that changes how it is displayed (e.g.
 *      characters were inserted or deleted, or tag information was
 *      changed).  This procedure must be called *before* a change is
 *      made, so that indexes in the display information are still
 *      valid.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The range of character between index1Ptr (inclusive) and
 *      index2Ptr (exclusive) will be redisplayed at some point in the
 *      future (the actual redisplay is scheduled as a when-idle handler).
 *
 *----------------------------------------------------------------------
 */

void
CkTextChanged(textPtr, index1Ptr, index2Ptr)
    CkText *textPtr;            /* Widget record for text widget. */
    CkTextIndex *index1Ptr;     /* Index of first character to redisplay. */
    CkTextIndex *index2Ptr;     /* Index of character just after last one
                                 * to redisplay. */
{
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    DLine *firstPtr, *lastPtr;
    CkTextIndex rounded;

    /*
     * Schedule both a redisplay and a recomputation of display information.
     * It's done here rather than the end of the procedure for two reasons:
     *
     * 1. If there are no display lines to update we'll want to return
     *    immediately, well before the end of the procedure.
     * 2. It's important to arrange for the redisplay BEFORE calling
     *    FreeDLines.  The reason for this is subtle and has to do with
     *    embedded windows.  The chunk delete procedure for an embedded
     *    window will schedule an idle handler to unmap the window.
     *    However, we want the idle handler for redisplay to be called
     *    first, so that it can put the embedded window back on the screen
     *    again (if appropriate).  This will prevent the window from ever
     *    being unmapped, and thereby avoid flashing.
     */

    if (!(dInfoPtr->flags & REDRAW_PENDING)) {
        Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
    }
    dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED;

    /*
     * 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:  round index1Ptr back to the beginning
     * of its text line, and include all the display lines after index2,
     * up to the end of its text line.  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.
     */

    rounded = *index1Ptr;
    rounded.charIndex = 0;
    firstPtr = FindDLine(dInfoPtr->dLinePtr, &rounded);
    if (firstPtr == NULL) {
        return;
    }
    lastPtr = FindDLine(dInfoPtr->dLinePtr, index2Ptr);
    while ((lastPtr != NULL)
            && (lastPtr->index.linePtr == index2Ptr->linePtr)) {
        lastPtr = lastPtr->nextPtr;
    }

    /*
     * Delete all the DLines from firstPtr up to but not including lastPtr.
     */

    FreeDLines(textPtr, firstPtr, lastPtr, 1);
}
\f
/*
 *----------------------------------------------------------------------
 *
 * CkTextRedrawTag --
 *
 *      This procedure is invoked to request a redraw of all characters
 *      in a given range that have a particular tag on or off.  It's
 *      called, for example, when tag options change.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Information on the screen may be redrawn, and the layout of
 *      the screen may change.
 *
 *----------------------------------------------------------------------
 */

void
CkTextRedrawTag(textPtr, index1Ptr, index2Ptr, tagPtr, withTag)
    CkText *textPtr;            /* Widget record for text widget. */
    CkTextIndex *index1Ptr;     /* First character in range to consider
                                 * for redisplay.  NULL means start at
                                 * beginning of text. */
    CkTextIndex *index2Ptr;     /* Character just after last one to consider
                                 * for redisplay.  NULL means process all
                                 * the characters in the text. */
    CkTextTag *tagPtr;          /* Information about tag. */
    int withTag;                /* 1 means redraw characters that have the
                                 * tag, 0 means redraw those without. */
{
    register DLine *dlPtr;
    DLine *endPtr;
    int tagOn;
    CkTextSearch search;
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    CkTextIndex endOfText, *endIndexPtr;

    /*
     * Round up the starting position if it's before the first line
     * visible on the screen (we only care about what's on the screen).
     */

    dlPtr = dInfoPtr->dLinePtr;
    if (dlPtr == NULL) {
        return;
    }
    if ((index1Ptr == NULL) || (CkTextIndexCmp(&dlPtr->index, index1Ptr) > 0)) {
        index1Ptr = &dlPtr->index;
    }

    /*
     * Set the stopping position if it wasn't specified.
     */

    if (index2Ptr == NULL) {
#if CK_USE_UTF
        index2Ptr = CkTextMakeByteIndex(textPtr->tree,
                CkBTreeNumLines(textPtr->tree), 0, &endOfText);
#else
        index2Ptr = CkTextMakeIndex(textPtr->tree,
                CkBTreeNumLines(textPtr->tree), 0, &endOfText);
#endif
    }

    /* 
     * Initialize a search through all transitions on the tag, starting
     * with the first transition where the tag's current state is different
     * from what it will eventually be.
     */

    CkBTreeStartSearch(index1Ptr, index2Ptr, tagPtr, &search);
    tagOn = CkBTreeCharTagged(index1Ptr, tagPtr);
    if (tagOn != withTag) {
        if (!CkBTreeNextTag(&search)) {
            return;
        }
    }

    /*
     * Schedule a redisplay and layout recalculation if they aren't
     * already pending.  This has to be done before calling FreeDLines,
     * for the reason given in CkTextChanged.
     */

    if (!(dInfoPtr->flags & REDRAW_PENDING)) {
        Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
    }
    dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED;

    /*
     * Each loop through the loop below is for one range of characters
     * where the tag's current state is different than its eventual
     * state.  At the top of the loop, search contains information about
     * the first character in the range.
     */

    while (1) {
        /*
         * Find the first DLine structure in the range.  Note: if the
         * desired character isn't the first in its text line, then look
         * for the character just before it instead.  This is needed to
         * handle the case where the first character of a wrapped
         * display line just got smaller, so that it now fits on the
         * line before:  need to relayout the line containing the
         * previous character.
         */

        if (search.curIndex.charIndex == 0) {
            dlPtr = FindDLine(dlPtr, &search.curIndex);
        } else {
            CkTextIndex tmp;

            tmp = search.curIndex;
            tmp.charIndex -= 1;
            dlPtr = FindDLine(dlPtr, &tmp);
        }
        if (dlPtr == NULL) {
            break;
        }

        /*
         * Find the first DLine structure that's past the end of the range.
         */

        if (!CkBTreeNextTag(&search)) {
            endIndexPtr = index2Ptr;
        } else {
            endIndexPtr = &search.curIndex;
        }
        endPtr = FindDLine(dlPtr, endIndexPtr);
        if ((endPtr != NULL) && (endPtr->index.linePtr == endIndexPtr->linePtr)
                && (endPtr->index.charIndex < endIndexPtr->charIndex)) {
            endPtr = endPtr->nextPtr;
        }

        /*
         * Delete all of the display lines in the range, so that they'll
         * be re-layed out and redrawn.
         */

        FreeDLines(textPtr, dlPtr, endPtr, 1);
        dlPtr = endPtr;

        /*
         * Find the first text line in the next range.
         */

        if (!CkBTreeNextTag(&search)) {
            break;
        }
    }
}
\f
/*
 *----------------------------------------------------------------------
 *
 * CkTextRelayoutWindow --
 *
 *      This procedure is called when something has happened that
 *      invalidates the whole layout of characters on the screen, such
 *      as a change in a configuration option for the overall text
 *      widget or a change in the window size.  It causes all display
 *      information to be recomputed and the window to be redrawn.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      All the display information will be recomputed for the window
 *      and the window will be redrawn.
 *
 *----------------------------------------------------------------------
 */

void
CkTextRelayoutWindow(textPtr)
    CkText *textPtr;            /* Widget record for text widget. */
{
    DInfo *dInfoPtr = textPtr->dInfoPtr;

    /*
     * Schedule the window redisplay.  See CkTextChanged for the
     * reason why this has to be done before any calls to FreeDLines.
     */

    if (!(dInfoPtr->flags & REDRAW_PENDING)) {
        Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
    }
    dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED;

    /*
     * Throw away all the current layout information.
     */

    FreeDLines(textPtr, dInfoPtr->dLinePtr, (DLine *) NULL, 1);
    dInfoPtr->dLinePtr = NULL;

    /*
     * Recompute some overall things for the layout.  Even if the
     * window gets very small, pretend that there's at least one
     * pixel of drawing space in it.
     */

    dInfoPtr->x = 0;
    dInfoPtr->y = 0;
    dInfoPtr->maxX = textPtr->winPtr->width;
    dInfoPtr->maxY = textPtr->winPtr->height;
    dInfoPtr->topOfEof = dInfoPtr->maxY;

    /*
     * If the upper-left character isn't the first in a line, recompute
     * it.  This is necessary because a change in the window's size
     * or options could change the way lines wrap.
     */

    if (textPtr->topIndex.charIndex != 0) {
        MeasureUp(textPtr, &textPtr->topIndex, 0, &textPtr->topIndex);
    }
}
\f
/*
 *----------------------------------------------------------------------
 *
 * CkTextSetYView --
 *
 *      This procedure is called to specify what lines are to be
 *      displayed in a text widget.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The display will (eventually) be updated so that the position
 *      given by "indexPtr" is visible on the screen at the position
 *      determined by "pickPlace".
 *
 *----------------------------------------------------------------------
 */

void
CkTextSetYView(textPtr, indexPtr, pickPlace)
    CkText *textPtr;            /* Widget record for text widget. */
    CkTextIndex *indexPtr;      /* Position that is to appear somewhere
                                 * in the view. */
    int pickPlace;              /* 0 means topLine must appear at top of
                                 * screen.  1 means we get to pick where it
                                 * appears:  minimize screen motion or else
                                 * display line at center of screen. */
{
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    register DLine *dlPtr;
    int bottomY, close, lineIndex;
    CkTextIndex tmpIndex, rounded;

    /*
     * If the specified position is the extra line at the end of the
     * text, round it back to the last real line.
     */

    lineIndex = CkBTreeLineIndex(indexPtr->linePtr);
    if (lineIndex == CkBTreeNumLines(indexPtr->tree)) {
        CkTextIndexBackChars(indexPtr, 1, &rounded);
        indexPtr = &rounded;
    }

    if (!pickPlace) {
        /*
         * The specified position must go at the top of the screen.
         * Just leave all the DLine's alone: we may be able to reuse
         * some of the information that's currently on the screen
         * without redisplaying it all.
         */

        if (indexPtr->charIndex == 0) {
            textPtr->topIndex = *indexPtr;
        } else {
            MeasureUp(textPtr, indexPtr, 0, &textPtr->topIndex);
        }
        goto scheduleUpdate;
    }

    /*
     * We have to pick where to display the index.  First, bring
     * the display information up to date and see if the index will be
     * completely visible in the current screen configuration.  If so
     * then there's nothing to do.
     */

    if (dInfoPtr->flags & DINFO_OUT_OF_DATE) {
        UpdateDisplayInfo(textPtr);
    }
    dlPtr = FindDLine(dInfoPtr->dLinePtr, indexPtr);
    if (dlPtr != NULL) {
        if ((dlPtr->y + dlPtr->height) > dInfoPtr->maxY) {
            /*
             * Part of the line hangs off the bottom of the screen;
             * pretend the whole line is off-screen.
             */

            dlPtr = NULL;
        } else if ((dlPtr->index.linePtr == indexPtr->linePtr)
                && (dlPtr->index.charIndex <= indexPtr->charIndex)) {
            return;
        }
    }

    /*
     * The desired line isn't already on-screen.
     */

    bottomY = (dInfoPtr->y + dInfoPtr->maxY)/2;
    close = (dInfoPtr->maxY - dInfoPtr->y)/3;
    if (dlPtr != NULL) {
        /*
         * The desired line is above the top of screen.  If it is
         * "close" to the top of the window then make it the top
         * line on the screen.
         */

        MeasureUp(textPtr, &textPtr->topIndex, close, &tmpIndex);
        if (CkTextIndexCmp(&tmpIndex, indexPtr) <= 0) {
            MeasureUp(textPtr, indexPtr, 0, &textPtr->topIndex);
            goto scheduleUpdate;
        }
    } else {
        /*
         * The desired line is below the bottom of the screen.  If it is
         * "close" to the bottom of the screen then position it at the
         * bottom of the screen.
         */

        MeasureUp(textPtr, indexPtr, close, &tmpIndex);
        if (FindDLine(dInfoPtr->dLinePtr, &tmpIndex) != NULL) {
            bottomY = dInfoPtr->maxY - dInfoPtr->y;
        }
    }

    /*
     * Our job now is to arrange the display so that indexPtr appears
     * as low on the screen as possible but with its bottom no lower
     * than bottomY.  BottomY is the bottom of the window if the
     * desired line is just below the current screen, otherwise it
     * is the center of the window.
     */

    MeasureUp(textPtr, indexPtr, bottomY, &textPtr->topIndex);

    scheduleUpdate:
    if (!(dInfoPtr->flags & REDRAW_PENDING)) {
        Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
    }
    dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED;
}
\f
/*
 *--------------------------------------------------------------
 *
 * MeasureUp --
 *
 *      Given one index, find the index of the first character
 *      on the highest display line that would be displayed no more
 *      than "distance" pixels above the given index.
 *
 * Results:
 *      *dstPtr is filled in with the index of the first character
 *      on a display line.  The display line is found by measuring
 *      up "distance" pixels above the pixel just below an imaginary
 *      display line that contains srcPtr.  If the display line
 *      that covers this coordinate actually extends above the 
 *      coordinate, then return the index of the next lower line
 *      instead (i.e. the returned index will be completely visible
 *      at or below the given y-coordinate).
 *
 * Side effects:
 *      None.
 *
 *--------------------------------------------------------------
 */

static void
MeasureUp(textPtr, srcPtr, distance, dstPtr)
    CkText *textPtr;            /* Text widget in which to measure. */
    CkTextIndex *srcPtr;        /* Index of character from which to start
                                 * measuring. */
    int distance;               /* Vertical distance in pixels measured
                                 * from the pixel just below the lowest
                                 * one in srcPtr's line. */
    CkTextIndex *dstPtr;        /* Index to fill in with result. */
{
    int lineNum;                /* Number of current line. */
    int charsToCount;           /* Maximum number of characters to measure
                                 * in current line. */
    CkTextIndex bestIndex;      /* Best candidate seen so far for result. */
    CkTextIndex index;
    DLine *dlPtr, *lowestPtr;
    int noBestYet;              /* 1 means bestIndex hasn't been set. */

    noBestYet = 1;
    charsToCount = srcPtr->charIndex + 1;
    index.tree = srcPtr->tree;
    for (lineNum = CkBTreeLineIndex(srcPtr->linePtr); lineNum >= 0;
            lineNum--) {
        /*
         * Layout an entire text line (potentially > 1 display line).
         * For the first line, which contains srcPtr, only layout the
         * part up through srcPtr (charsToCount is non-infinite to
         * accomplish this).  Make a list of all the display lines
         * in backwards order (the lowest DLine on the screen is first
         * in the list).
         */

        index.linePtr = CkBTreeFindLine(srcPtr->tree, lineNum);
        index.charIndex = 0;
        lowestPtr = NULL;
        do {
            dlPtr = LayoutDLine(textPtr, &index);
            dlPtr->nextPtr = lowestPtr;
            lowestPtr = dlPtr;
#if CK_USE_UTF
            CkTextIndexForwBytes(&index, dlPtr->count, &index);
#else
            CkTextIndexForwChars(&index, dlPtr->count, &index);
#endif
            charsToCount -= dlPtr->count;
        } while ((charsToCount > 0) && (index.linePtr == dlPtr->index.linePtr));

        /*
         * Scan through the display lines to see if we've covered enough
         * vertical distance.  If so, save the starting index for the
         * line at the desired location.
         */

        for (dlPtr = lowestPtr; dlPtr != NULL; dlPtr = dlPtr->nextPtr) {
            distance -= dlPtr->height;
            if (distance < 0) {
                *dstPtr = (noBestYet) ? dlPtr->index : bestIndex;
                break;
            }
            bestIndex = dlPtr->index;
            noBestYet = 0;
        }

        /*
         * Discard the display lines, then either return or prepare
         * for the next display line to lay out.
         */

        FreeDLines(textPtr, lowestPtr, (DLine *) NULL, 0);
        if (distance < 0) {
            return;
        }
        charsToCount = INT_MAX;         /* Consider all chars. in next line. */
    }

    /*
     * Ran off the beginning of the text.  Return the first character
     * in the text.
     */
#if CK_USE_UTF
    CkTextMakeByteIndex(textPtr->tree, 0, 0, dstPtr);
#else
    CkTextMakeIndex(textPtr->tree, 0, 0, dstPtr);
#endif
}
\f
/*
 *--------------------------------------------------------------
 *
 * CkTextSeeCmd --
 *
 *      This procedure is invoked to process the "see" option for
 *      the widget command for text widgets. See the user documentation
 *      for details on what it does.
 *
 * Results:
 *      A standard Tcl result.
 *
 * Side effects:
 *      See the user documentation.
 *
 *--------------------------------------------------------------
 */

int
CkTextSeeCmd(textPtr, interp, argc, argv)
    CkText *textPtr;            /* Information about text widget. */
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings.  Someone else has already
                                 * parsed this command enough to know that
                                 * argv[1] is "see". */
{
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    CkTextIndex index;
    int x, y, width, height, lineWidth, charCount, oneThird, delta;
    DLine *dlPtr;
    CkTextDispChunk *chunkPtr;

    if (argc != 3) {
        Tcl_AppendResult(interp, "wrong # args: should be \"",
                argv[0], " see index\"", (char *) NULL);
        return TCL_ERROR;
    }
    if (CkTextGetIndex(interp, textPtr, argv[2], &index) != TCL_OK) {
        return TCL_ERROR;
    }

    /*
     * If the specified position is the extra line at the end of the
     * text, round it back to the last real line.
     */

    if (CkBTreeLineIndex(index.linePtr) == CkBTreeNumLines(index.tree)) {
        CkTextIndexBackChars(&index, 1, &index);
    }

    /*
     * First get the desired position into the vertical range of the window.
     */

    CkTextSetYView(textPtr, &index, 1);

    /*
     * Now make sure that the character is in view horizontally.
     */

    if (dInfoPtr->flags & DINFO_OUT_OF_DATE) {
        UpdateDisplayInfo(textPtr);
    }
    lineWidth = dInfoPtr->maxX - dInfoPtr->x;
    if (dInfoPtr->maxLength < lineWidth) {
        return TCL_OK;
    }

    /*
     * Find the chunk that contains the desired index.
     */

    dlPtr = FindDLine(dInfoPtr->dLinePtr, &index);
    charCount = index.charIndex - dlPtr->index.charIndex;
    for (chunkPtr = dlPtr->chunkPtr; ; chunkPtr = chunkPtr->nextPtr) {
        if (charCount < chunkPtr->numChars) {
            break;
        }
        charCount -= chunkPtr->numChars;
    }

    /*
     * Call a chunk-specific procedure to find the horizontal range of
     * the character within the chunk.
     */

    (*chunkPtr->bboxProc)(chunkPtr, charCount, dlPtr->y,
            dlPtr->height, 0, &x, &y, &width, &height);
    delta = x - dInfoPtr->curOffset;
    oneThird = lineWidth/3;
    if (delta < 0) {
        if (delta < -oneThird) {
            dInfoPtr->newCharOffset = (x - lineWidth/2);
        } else {
            dInfoPtr->newCharOffset -= -delta;
        }
    } else {
        delta -= (lineWidth - width);
        if (delta >= 0) {
            if (delta > oneThird) {
                dInfoPtr->newCharOffset = (x - lineWidth/2);
            } else {
                dInfoPtr->newCharOffset += delta + 1;
            }
        } else {
            return TCL_OK;
        }
    }
    dInfoPtr->flags |= DINFO_OUT_OF_DATE;
    if (!(dInfoPtr->flags & REDRAW_PENDING)) {
        dInfoPtr->flags |= REDRAW_PENDING;
        Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
    }
    return TCL_OK;
}
\f
/*
 *--------------------------------------------------------------
 *
 * CkTextXviewCmd --
 *
 *      This procedure is invoked to process the "xview" option for
 *      the widget command for text widgets. See the user documentation
 *      for details on what it does.
 *
 * Results:
 *      A standard Tcl result.
 *
 * Side effects:
 *      See the user documentation.
 *
 *--------------------------------------------------------------
 */

int
CkTextXviewCmd(textPtr, interp, argc, argv)
    CkText *textPtr;            /* Information about text widget. */
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings.  Someone else has already
                                 * parsed this command enough to know that
                                 * argv[1] is "xview". */
{
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    int type, charsPerPage, count, newOffset;
    double fraction;

    if (dInfoPtr->flags & DINFO_OUT_OF_DATE) {
        UpdateDisplayInfo(textPtr);
    }

    if (argc == 2) {
        GetXView(interp, textPtr, 0);
        return TCL_OK;
    }

    newOffset = dInfoPtr->newCharOffset;
    type = Ck_GetScrollInfo(interp, argc, argv, &fraction, &count);
    switch (type) {
        case CK_SCROLL_ERROR:
            return TCL_ERROR;
        case CK_SCROLL_MOVETO:
            newOffset = (int) (fraction * dInfoPtr->maxLength);
            break;
        case CK_SCROLL_PAGES:
            charsPerPage = dInfoPtr->maxX - dInfoPtr->x - 2;
            if (charsPerPage < 1) {
                charsPerPage = 1;
            }
            newOffset += charsPerPage*count;
            break;
        case CK_SCROLL_UNITS:
            newOffset += count;
            break;
    }

    dInfoPtr->newCharOffset = newOffset;
    dInfoPtr->flags |= DINFO_OUT_OF_DATE;
    if (!(dInfoPtr->flags & REDRAW_PENDING)) {
        dInfoPtr->flags |= REDRAW_PENDING;
        Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
    }
    return TCL_OK;
}
\f
/*
 *----------------------------------------------------------------------
 *
 * ScrollByLines --
 *
 *      This procedure is called to scroll a text widget up or down
 *      by a given number of lines.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The view in textPtr's window changes to reflect the value
 *      of "offset".
 *
 *----------------------------------------------------------------------
 */

static void
ScrollByLines(textPtr, offset)
    CkText *textPtr;            /* Widget to scroll. */
    int offset;                 /* Amount by which to scroll, in *screen*
                                 * lines.  Positive means that information
                                 * later in text becomes visible, negative
                                 * means that information earlier in the
                                 * text becomes visible. */
{
    int i, charsToCount, lineNum;
    CkTextIndex new, index;
    CkTextLine *lastLinePtr;
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    DLine *dlPtr, *lowestPtr;

    if (offset < 0) {
        /*
         * Must scroll up (to show earlier information in the text).
         * The code below is similar to that in MeasureUp, except that
         * it counts lines instead of pixels.
         */

        charsToCount = textPtr->topIndex.charIndex + 1;
        index.tree = textPtr->tree;
        offset--;                       /* Skip line containing topIndex. */
        for (lineNum = CkBTreeLineIndex(textPtr->topIndex.linePtr);
                lineNum >= 0; lineNum--) {
            index.linePtr = CkBTreeFindLine(textPtr->tree, lineNum);
            index.charIndex = 0;
            lowestPtr = NULL;
            do {
                dlPtr = LayoutDLine(textPtr, &index);
                dlPtr->nextPtr = lowestPtr;
                lowestPtr = dlPtr;
#if CK_USE_UTF
                CkTextIndexForwBytes(&index, dlPtr->count, &index);
#else
                CkTextIndexForwChars(&index, dlPtr->count, &index);
#endif
                charsToCount -= dlPtr->count;
            } while ((charsToCount > 0)
                    && (index.linePtr == dlPtr->index.linePtr));

            for (dlPtr = lowestPtr; dlPtr != NULL; dlPtr = dlPtr->nextPtr) {
                offset++;
                if (offset == 0) {
                    textPtr->topIndex = dlPtr->index;
                    break;
                }
            }
    
            /*
             * Discard the display lines, then either return or prepare
             * for the next display line to lay out.
             */
    
            FreeDLines(textPtr, lowestPtr, (DLine *) NULL, 0);
            if (offset >= 0) {
                goto scheduleUpdate;
            }
            charsToCount = INT_MAX;
        }
    
        /*
         * Ran off the beginning of the text.  Return the first character
         * in the text.
         */
#if CK_USE_UTF
        CkTextMakeByteIndex(textPtr->tree, 0, 0, &textPtr->topIndex);
#else
        CkTextMakeIndex(textPtr->tree, 0, 0, &textPtr->topIndex);
#endif
    } else {
        /*
         * Scrolling down, to show later information in the text.
         * Just count lines from the current top of the window.
         */

        lastLinePtr = CkBTreeFindLine(textPtr->tree,
                CkBTreeNumLines(textPtr->tree));
        for (i = 0; i < offset; i++) {
            dlPtr = LayoutDLine(textPtr, &textPtr->topIndex);
            dlPtr->nextPtr = NULL;
#if CK_USE_UTF
            if (dlPtr->length == 0 && dlPtr->height == 0) {
                offset++;
            }
            CkTextIndexForwBytes(&textPtr->topIndex, dlPtr->count, &new);
#else
            CkTextIndexForwChars(&textPtr->topIndex, dlPtr->count, &new);
#endif
            FreeDLines(textPtr, dlPtr, (DLine *) NULL, 0);
            if (new.linePtr == lastLinePtr) {
                break;
            }
            textPtr->topIndex = new;
        }
    }

    scheduleUpdate:
    if (!(dInfoPtr->flags & REDRAW_PENDING)) {
        Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
    }
    dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED;
}
\f
/*
 *--------------------------------------------------------------
 *
 * CkTextYviewCmd --
 *
 *      This procedure is invoked to process the "yview" option for
 *      the widget command for text widgets. See the user documentation
 *      for details on what it does.
 *
 * Results:
 *      A standard Tcl result.
 *
 * Side effects:
 *      See the user documentation.
 *
 *--------------------------------------------------------------
 */

int
CkTextYviewCmd(textPtr, interp, argc, argv)
    CkText *textPtr;            /* Information about text widget. */
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings.  Someone else has already
                                 * parsed this command enough to know that
                                 * argv[1] is "yview". */
{
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    int pickPlace, lineNum, type, lineHeight;
    int pixels, count;
    size_t switchLength;
    double fraction;
    CkTextIndex index, new;
    CkTextLine *lastLinePtr;
    DLine *dlPtr;
#if CK_USE_UTF
    int bytesInLine;
#endif

    if (dInfoPtr->flags & DINFO_OUT_OF_DATE) {
        UpdateDisplayInfo(textPtr);
    }

    if (argc == 2) {
        GetYView(interp, textPtr, 0);
        return TCL_OK;
    }

    /*
     * Next, handle the old syntax: "pathName yview ?-pickplace? where"
     */

    pickPlace = 0;
    if (argv[2][0] == '-') {
        switchLength = strlen(argv[2]);
        if ((switchLength >= 2)
                && (strncmp(argv[2], "-pickplace", switchLength) == 0)) {
            pickPlace = 1;
            if (argc != 4) {
                Tcl_AppendResult(interp, "wrong # args: should be \"",
                        argv[0], " yview -pickplace lineNum|index\"",
                        (char *) NULL);
                return TCL_ERROR;
            }
        }
    }
    if ((argc == 3) || pickPlace) {
        if (Tcl_GetInt(interp, argv[2+pickPlace], &lineNum) == TCL_OK) {
#if CK_USE_UTF
            CkTextMakeByteIndex(textPtr->tree, lineNum, 0, &index);
#else
            CkTextMakeIndex(textPtr->tree, lineNum, 0, &index);
#endif
            CkTextSetYView(textPtr, &index, 0);
            return TCL_OK;
        }
    
        /*
         * The argument must be a regular text index.
         */
    
        Tcl_ResetResult(interp);
        if (CkTextGetIndex(interp, textPtr, argv[2+pickPlace],
                &index) != TCL_OK) {
            return TCL_ERROR;
        }
        CkTextSetYView(textPtr, &index, pickPlace);
        return TCL_OK;
    }

    /*
     * New syntax: dispatch based on argv[2].
     */

    type = Ck_GetScrollInfo(interp, argc, argv, &fraction, &count);
    switch (type) {
        case CK_SCROLL_ERROR:
            return TCL_ERROR;
        case CK_SCROLL_MOVETO:
#if CK_USE_UTF
            if (fraction > 1.0) {
                fraction = 1.0;
            }
            if (fraction < 0) {
                fraction = 0;
            }
            fraction *= CkBTreeNumLines(textPtr->tree);
            lineNum = (int) fraction;
            CkTextMakeByteIndex(textPtr->tree, lineNum, 0, &index);
            bytesInLine = CkBTreeCharsInLine(index.linePtr);
            index.charIndex = (int)((bytesInLine * (fraction-lineNum)) + 0.5);
            if (index.charIndex >= bytesInLine) {
                CkTextMakeByteIndex(textPtr->tree, lineNum + 1, 0, &index);
            }
#else
            fraction *= CkBTreeNumLines(textPtr->tree);
            lineNum = (int) fraction;
            CkTextMakeIndex(textPtr->tree, lineNum+1, 0, &index);
            CkTextIndexBackChars(&index, 1, &index);
            index.charIndex = (int) ((index.charIndex+1)*(fraction-lineNum));
#endif
            CkTextSetYView(textPtr, &index, 0);
            break;
        case CK_SCROLL_PAGES:
            /*
             * Scroll up or down by screenfulls.  Actually, use the
             * window height minus two lines, so that there's some
             * overlap between adjacent pages.
             */

            lineHeight = 1;
            if (count < 0) {
                pixels = (dInfoPtr->maxY - 2*lineHeight - dInfoPtr->y)*(-count)
                        + lineHeight;
                MeasureUp(textPtr, &textPtr->topIndex, pixels, &new);
                if (CkTextIndexCmp(&textPtr->topIndex, &new) == 0) {
                    /*
                     * A page of scrolling ended up being less than one line.
                     * Scroll one line anyway.
                     */

                    count = -1;
                    goto scrollByLines;
                }
                textPtr->topIndex = new;
            } else {
                /*
                 * Scrolling down by pages.  Layout lines starting at the
                 * top index and count through the desired vertical distance.
                 */

                pixels = (dInfoPtr->maxY - 2*lineHeight - dInfoPtr->y)*count;
                lastLinePtr = CkBTreeFindLine(textPtr->tree,
                        CkBTreeNumLines(textPtr->tree));
                do {
                    dlPtr = LayoutDLine(textPtr, &textPtr->topIndex);
                    dlPtr->nextPtr = NULL;
#if CK_USE_UTF
                    CkTextIndexForwBytes(&textPtr->topIndex, dlPtr->count,
                            &new);
#else
                    CkTextIndexForwChars(&textPtr->topIndex, dlPtr->count,
                            &new);
#endif
                    pixels -= dlPtr->height;
                    FreeDLines(textPtr, dlPtr, (DLine *) NULL, 0);
                    if (new.linePtr == lastLinePtr) {
                        break;
                    }
                    textPtr->topIndex = new;
                } while (pixels > 0);
            }
            if (!(dInfoPtr->flags & REDRAW_PENDING)) {
                Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
            }
            dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED;
            break;
        case CK_SCROLL_UNITS:
            scrollByLines:
            ScrollByLines(textPtr, count);
            break;
    }
    return TCL_OK;
}
\f
/*
 *----------------------------------------------------------------------
 *
 * GetXView --
 *
 *      This procedure computes the fractions that indicate what's
 *      visible in a text window and, optionally, evaluates a
 *      Tcl script to report them to the text's associated scrollbar.
 *
 * Results:
 *      If report is zero, then interp->result is filled in with
 *      two real numbers separated by a space, giving the position of
 *      the left and right edges of the window as fractions from 0 to
 *      1, where 0 means the left edge of the text and 1 means the right
 *      edge.  If report is non-zero, then interp->result isn't modified
 *      directly, but instead a script is evaluated in interp to report
 *      the new horizontal scroll position to the scrollbar (if the scroll
 *      position hasn't changed then no script is invoked).
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static void
GetXView(interp, textPtr, report)
    Tcl_Interp *interp;                 /* If "report" is FALSE, string
                                         * describing visible range gets
                                         * stored in interp->result. */
    CkText *textPtr;                    /* Information about text widget. */
    int report;                         /* Non-zero means report info to
                                         * scrollbar if it has changed. */
{
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    char buffer[200];
    double first, last;
    int code;

    if (dInfoPtr->maxLength > 0) {
        first = ((double) dInfoPtr->curOffset)
                / dInfoPtr->maxLength;
        last = first + ((double) (dInfoPtr->maxX - dInfoPtr->x))
                / dInfoPtr->maxLength;
        if (last > 1.0) {
            last = 1.0;
        }
    } else {
        first = 0;
        last = 1.0;
    }
    if (!report) {
        sprintf(interp->result, "%g %g", first, last);
        return;
    }
    if ((first == dInfoPtr->xScrollFirst) && (last == dInfoPtr->xScrollLast)) {
        return;
    }
    dInfoPtr->xScrollFirst = first;
    dInfoPtr->xScrollLast = last;
    sprintf(buffer, " %g %g", first, last);
    code = Tcl_VarEval(interp, textPtr->xScrollCmd,
            buffer, (char *) NULL);
    if (code != TCL_OK) {
        Tcl_AddErrorInfo(interp,
                "\n    (horizontal scrolling command executed by text)");
        Tk_BackgroundError(interp);
    }
}
\f
/*
 *----------------------------------------------------------------------
 *
 * GetYView --
 *
 *      This procedure computes the fractions that indicate what's
 *      visible in a text window and, optionally, evaluates a
 *      Tcl script to report them to the text's associated scrollbar.
 *
 * Results:
 *      If report is zero, then interp->result is filled in with
 *      two real numbers separated by a space, giving the position of
 *      the top and bottom of the window as fractions from 0 to 1, where
 *      0 means the beginning of the text and 1 means the end.  If
 *      report is non-zero, then interp->result isn't modified directly,
 *      but a script is evaluated in interp to report the new scroll
 *      position to the scrollbar (if the scroll position hasn't changed
 *      then no script is invoked).
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static void
GetYView(interp, textPtr, report)
    Tcl_Interp *interp;                 /* If "report" is FALSE, string
                                         * describing visible range gets
                                         * stored in interp->result. */
    CkText *textPtr;                    /* Information about text widget. */
    int report;                         /* Non-zero means report info to
                                         * scrollbar if it has changed. */
{
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    char buffer[200];
    double first, last;
    DLine *dlPtr;
    int totalLines, code, count;

    dlPtr = dInfoPtr->dLinePtr;
    totalLines = CkBTreeNumLines(textPtr->tree);
    first = ((double) CkBTreeLineIndex(dlPtr->index.linePtr))
            + ((double) dlPtr->index.charIndex)
            / (CkBTreeCharsInLine(dlPtr->index.linePtr));
    first /= totalLines;
    while (1) {
        if ((dlPtr->y + dlPtr->height) > dInfoPtr->maxY) {
            /*
             * The last line is only partially visible, so don't
             * count its characters in what's visible.
             */
            count = 0;
            break;
        }
        if (dlPtr->nextPtr == NULL) {
            count = dlPtr->count;
            break;
        }
        dlPtr = dlPtr->nextPtr;
    }
    last = ((double) CkBTreeLineIndex(dlPtr->index.linePtr))
            + ((double) (dlPtr->index.charIndex + count))
            / (CkBTreeCharsInLine(dlPtr->index.linePtr));
    last /= totalLines;
    if (!report) {
        sprintf(interp->result, "%g %g", first, last);
        return;
    }
    if ((first == dInfoPtr->yScrollFirst) && (last == dInfoPtr->yScrollLast)) {
        return;
    }
    dInfoPtr->yScrollFirst = first;
    dInfoPtr->yScrollLast = last;
    sprintf(buffer, " %g %g", first, last);
    code = Tcl_VarEval(interp, textPtr->yScrollCmd,
            buffer, (char *) NULL);
    if (code != TCL_OK) {
        Tcl_AddErrorInfo(interp,
                "\n    (vertical scrolling command executed by text)");
        Tk_BackgroundError(interp);
    }
}
\f
/*
 *----------------------------------------------------------------------
 *
 * FindDLine --
 *
 *      This procedure is called to find the DLine corresponding to a
 *      given text index.
 *
 * Results:
 *      The return value is a pointer to the first DLine found in the
 *      list headed by dlPtr that displays information at or after the
 *      specified position.  If there is no such line in the list then
 *      NULL is returned.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static DLine *
FindDLine(dlPtr, indexPtr)
    register DLine *dlPtr;      /* Pointer to first in list of DLines
                                 * to search. */
    CkTextIndex *indexPtr;      /* Index of desired character. */
{
    CkTextLine *linePtr;

    if (dlPtr == NULL) {
        return NULL;
    }
    if (CkBTreeLineIndex(indexPtr->linePtr)
            < CkBTreeLineIndex(dlPtr->index.linePtr)) {
        /*
         * The first display line is already past the desired line.
         */
        return dlPtr;
    }

    /*
     * Find the first display line that covers the desired text line.
     */

    linePtr = dlPtr->index.linePtr;
    while (linePtr != indexPtr->linePtr) {
        while (dlPtr->index.linePtr == linePtr) {
            dlPtr = dlPtr->nextPtr;
            if (dlPtr == NULL) {
                return NULL;
            }
        }
        linePtr = CkBTreeNextLine(linePtr);
        if (linePtr == NULL) {
            panic("FindDLine reached end of text");
        }
    }
    if (indexPtr->linePtr != dlPtr->index.linePtr) {
        return dlPtr;
    }

    /*
     * Now get to the right position within the text line.
     */

    while (indexPtr->charIndex >= (dlPtr->index.charIndex + dlPtr->count)) {
        dlPtr = dlPtr->nextPtr;
        if ((dlPtr == NULL) || (dlPtr->index.linePtr != indexPtr->linePtr)) {
            break;
        }
    }
    return dlPtr;
}
\f
/*
 *----------------------------------------------------------------------
 *
 * CkTextPixelIndex --
 *
 *      Given an (x,y) coordinate on the screen, find the location of
 *      the character closest to that location.
 *
 * Results:
 *      The index at *indexPtr is modified to refer to the character
 *      on the display that is closest to (x,y).
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

void
CkTextPixelIndex(textPtr, x, y, indexPtr)
    CkText *textPtr;            /* Widget record for text widget. */
    int x, y;                   /* Pixel coordinates of point in widget's
                                 * window. */
    CkTextIndex *indexPtr;      /* This index gets filled in with the
                                 * index of the character nearest to (x,y). */
{
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    register DLine *dlPtr;
    register CkTextDispChunk *chunkPtr;

    /*
     * Make sure that all of the layout information about what's
     * displayed where on the screen is up-to-date.
     */

    if (dInfoPtr->flags & DINFO_OUT_OF_DATE) {
        UpdateDisplayInfo(textPtr);
    }

    /*
     * If the coordinates are above the top of the window, then adjust
     * them to refer to the upper-right corner of the window.  If they're
     * off to one side or the other, then adjust to the closest side.
     */

    if (y < dInfoPtr->y) {
        y = dInfoPtr->y;
        x = dInfoPtr->x;
    }
    if (x >= dInfoPtr->maxX) {
        x = dInfoPtr->maxX - 1;
    }
    if (x < dInfoPtr->x) {
        x = dInfoPtr->x;
    }

    /*
     * Find the display line containing the desired y-coordinate.
     */

    for (dlPtr = dInfoPtr->dLinePtr; y >= (dlPtr->y + dlPtr->height);
            dlPtr = dlPtr->nextPtr) {
        if (dlPtr->nextPtr == NULL) {
            /*
             * Y-coordinate is off the bottom of the displayed text.
             * Use the last character on the last line.
             */

            x = dInfoPtr->maxX - 1;
            break;
        }
    }

    /*
     * Scan through the line's chunks to find the one that contains
     * the desired x-coordinate.  Before doing this, translate the
     * x-coordinate from the coordinate system of the window to the
     * coordinate system of the line (to take account of x-scrolling).
     */

    *indexPtr = dlPtr->index;
    x = x - dInfoPtr->x + dInfoPtr->curOffset;
    for (chunkPtr = dlPtr->chunkPtr; x >= (chunkPtr->x + chunkPtr->width);
            indexPtr->charIndex += chunkPtr->numChars,
            chunkPtr = chunkPtr->nextPtr) {
        if (chunkPtr->nextPtr == NULL) {
#if CK_USE_UTF
            indexPtr->charIndex += chunkPtr->numChars;
            CkTextIndexBackChars(indexPtr, 1, indexPtr);
#else
            indexPtr->charIndex += chunkPtr->numChars - 1;
#endif
            return;
        }
    }

    /*
     * If the chunk has more than one character in it, ask it which
     * character is at the desired location.
     */

    if (chunkPtr->numChars > 1) {
        indexPtr->charIndex += (*chunkPtr->measureProc)(chunkPtr, x);
    }
}
\f
/*
 *----------------------------------------------------------------------
 *
 * CkTextCharBbox --
 *
 *      Given an index, find the bounding box of the screen area
 *      occupied by that character.
 *
 * Results:
 *      Zero is returned if the character is on the screen.  -1
 *      means the character isn't on the screen.  If the return value
 *      is 0, then the bounding box of the part of the character that's
 *      visible on the screen is returned to *xPtr, *yPtr, *widthPtr,
 *      and *heightPtr.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

int
CkTextCharBbox(textPtr, indexPtr, xPtr, yPtr, widthPtr, heightPtr)
    CkText *textPtr;            /* Widget record for text widget. */
    CkTextIndex *indexPtr;      /* Index of character whose bounding
                                 * box is desired. */
    int *xPtr, *yPtr;           /* Filled with character's upper-left
                                 * coordinate. */
    int *widthPtr, *heightPtr;  /* Filled in with character's dimensions. */
{
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    DLine *dlPtr;
    register CkTextDispChunk *chunkPtr;
    int index;

    /*
     * Make sure that all of the screen layout information is up to date.
     */

    if (dInfoPtr->flags & DINFO_OUT_OF_DATE) {
        UpdateDisplayInfo(textPtr);
    }

    /*
     * Find the display line containing the desired index.
     */

    dlPtr = FindDLine(dInfoPtr->dLinePtr, indexPtr);
    if ((dlPtr == NULL) || (CkTextIndexCmp(&dlPtr->index, indexPtr) > 0)) {
        return -1;
    }

    /*
     * Find the chunk within the line that contains the desired
     * index.
     */

    index = indexPtr->charIndex - dlPtr->index.charIndex;
    for (chunkPtr = dlPtr->chunkPtr; ; chunkPtr = chunkPtr->nextPtr) {
        if (chunkPtr == NULL) {
            return -1;
        }
        if (index < chunkPtr->numChars) {
            break;
        }
        index -= chunkPtr->numChars;
    }

    /*
     * Call a chunk-specific procedure to find the horizontal range of
     * the character within the chunk, then fill in the vertical range.
     * The x-coordinate returned by bboxProc is a coordinate within a
     * line, not a coordinate on the screen.  Translate it to reflect
     * horizontal scrolling.
     */

    (*chunkPtr->bboxProc)(chunkPtr, index, dlPtr->y,
            dlPtr->height, 0, xPtr, yPtr, widthPtr,
            heightPtr);
    *xPtr = *xPtr + dInfoPtr->x - dInfoPtr->curOffset;
    if ((index == (chunkPtr->numChars-1)) && (chunkPtr->nextPtr == NULL)) {
        /*
         * Last character in display line.  Give it all the space up to
         * the line.
         */

        if (*xPtr > dInfoPtr->maxX) {
            *xPtr = dInfoPtr->maxX;
        }
        *widthPtr = dInfoPtr->maxX - *xPtr;
    }
    if ((*xPtr + *widthPtr) <= dInfoPtr->x) {
        return -1;
    }
    if ((*xPtr + *widthPtr) > dInfoPtr->maxX) {
        *widthPtr = dInfoPtr->maxX - *xPtr;
        if (*widthPtr <= 0) {
            return -1;
        }
    }
    if ((*yPtr + *heightPtr) > dInfoPtr->maxY) {
        *heightPtr = dInfoPtr->maxY - *yPtr;
        if (*heightPtr <= 0) {
            return -1;
        }
    }
    return 0;
}
\f
/*
 *----------------------------------------------------------------------
 *
 * CkTextDLineInfo --
 *
 *      Given an index, return information about the display line
 *      containing that character.
 *
 * Results:
 *      Zero is returned if the character is on the screen.  -1
 *      means the character isn't on the screen.  If the return value
 *      is 0, then information is returned in the variables pointed
 *      to by xPtr, yPtr, widthPtr, heightPtr, and basePtr.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

int
CkTextDLineInfo(textPtr, indexPtr, xPtr, yPtr, widthPtr, heightPtr, basePtr)
    CkText *textPtr;            /* Widget record for text widget. */
    CkTextIndex *indexPtr;      /* Index of character whose bounding
                                 * box is desired. */
    int *xPtr, *yPtr;           /* Filled with line's upper-left
                                 * coordinate. */
    int *widthPtr, *heightPtr;  /* Filled in with line's dimensions. */
    int *basePtr;               /* Filled in with the baseline position,
                                 * measured as an offset down from *yPtr. */
{
    DInfo *dInfoPtr = textPtr->dInfoPtr;
    DLine *dlPtr;

    /*
     * Make sure that all of the screen layout information is up to date.
     */

    if (dInfoPtr->flags & DINFO_OUT_OF_DATE) {
        UpdateDisplayInfo(textPtr);
    }

    /*
     * Find the display line containing the desired index.
     */

    dlPtr = FindDLine(dInfoPtr->dLinePtr, indexPtr);
    if ((dlPtr == NULL) || (CkTextIndexCmp(&dlPtr->index, indexPtr) > 0)) {
        return -1;
    }

    *xPtr = dInfoPtr->x - dInfoPtr->curOffset + dlPtr->chunkPtr->x;
    *widthPtr = dlPtr->length - dlPtr->chunkPtr->x;
    *yPtr = dlPtr->y;
    if ((dlPtr->y + dlPtr->height) > dInfoPtr->maxY) {
        *heightPtr = dInfoPtr->maxY - dlPtr->y;
    } else {
        *heightPtr = dlPtr->height;
    }
    *basePtr = 0;
    return 0;
}
\f
/*
 *--------------------------------------------------------------
 *
 * CkTextCharLayoutProc --
 *
 *      This procedure is the "layoutProc" for character segments.
 *
 * Results:
 *      If there is something to display for the chunk then a
 *      non-zero value is returned and the fields of chunkPtr
 *      will be filled in (see the declaration of CkTextDispChunk
 *      in ckText.h for details).  If zero is returned it means
 *      that no characters from this chunk fit in the window.
 *      If -1 is returned it means that this segment just doesn't
 *      need to be displayed (never happens for text).
 *
 * Side effects:
 *      Memory is allocated to hold additional information about
 *      the chunk.
 *
 *--------------------------------------------------------------
 */

int
CkTextCharLayoutProc(textPtr, indexPtr, segPtr, offset, maxX, maxChars,
        noCharsYet, wrapMode, chunkPtr)
    CkText *textPtr;            /* Text widget being layed out. */
    CkTextIndex *indexPtr;      /* Index of first character to lay out
                                 * (corresponds to segPtr and offset). */
    CkTextSegment *segPtr;      /* Segment being layed out. */
    int offset;                 /* Offset within segment of first character
                                 * to consider. */
    int maxX;                   /* Chunk must not occupy pixels at this
                                 * position or higher. */
    int maxChars;               /* Chunk must not include more than this
                                 * many characters. */
    int noCharsYet;             /* Non-zero means no characters have been
                                 * assigned to this display line yet. */
    Ck_Uid wrapMode;            /* How to handle line wrapping: ckTextCharUid,
                                 * ckTextNoneUid, or ckTextWordUid. */
    register CkTextDispChunk *chunkPtr;
                                /* Structure to fill in with information
                                 * about this chunk.  The x field has already
                                 * been set by the caller. */
{
    int nextX, charsThatFit, count, dummy;
    CharInfo *ciPtr;
    char *p;
    CkTextSegment *nextPtr;
    CkWindow *winPtr = textPtr->winPtr;

    /*
     * Figure out how many characters will fit in the space we've got.
     * Include the next character, even though it won't fit completely,
     * if any of the following is true:
     *   (a) the chunk contains no characters and the display line contains
     *       no characters yet (i.e. the line isn't wide enough to hold
     *       even a single character).
     *   (b) at least one pixel of the character is visible, we haven't
     *       already exceeded the character limit, and the next character
     *       is a white space character.
     */

    p = segPtr->body.chars + offset;
    CkMeasureChars(winPtr->mainPtr, p, maxChars, chunkPtr->x,
        maxX, 0, CK_IGNORE_TABS, &nextX, &charsThatFit);
    if (charsThatFit < maxChars) {
        if ((charsThatFit == 0) && noCharsYet) {
            charsThatFit = 1;
            CkMeasureChars(winPtr->mainPtr, p, 1, chunkPtr->x, INT_MAX, 0,
                CK_IGNORE_TABS, &nextX, &dummy);
        }
        if (p[charsThatFit] == '\n') {
            /*
             * A newline character takes up no space, so if the previous
             * character fits then so does the newline.
             */

            charsThatFit++;
        }
        if (charsThatFit == 0) {
            return 0;
        }
    }

    /*
     * Fill in the chunk structure and allocate and initialize a
     * CharInfo structure.  If the last character is a newline
     * then don't bother to display it.
     */

    chunkPtr->displayProc = CharDisplayProc;
    chunkPtr->undisplayProc = CharUndisplayProc;
    chunkPtr->measureProc = CharMeasureProc;
    chunkPtr->bboxProc = CharBboxProc;
    chunkPtr->numChars = charsThatFit;
    chunkPtr->minHeight = 1;
    chunkPtr->width = nextX - chunkPtr->x;
    chunkPtr->breakIndex = -1;
    ciPtr = (CharInfo *) ckalloc((unsigned)
            (sizeof(CharInfo) - 3 + charsThatFit));
    chunkPtr->clientData = (ClientData) ciPtr;
    ciPtr->numChars = charsThatFit;
    ciPtr->winPtr = textPtr->winPtr;
    strncpy(ciPtr->chars, p, (size_t) charsThatFit);
    if (p[charsThatFit-1] == '\n') {
        ciPtr->numChars--;
    }

    /*
     * 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 segment (ignoring those with zero size)
     * is not a character segment.
     */

    if (wrapMode != ckTextWordUid) {
        chunkPtr->breakIndex = chunkPtr->numChars;
    } else {
        for (count = charsThatFit, p += charsThatFit-1; count > 0;
                count--, p--) {
            if (isspace((unsigned char) *p)) {
                chunkPtr->breakIndex = count;
                break;
            }
        }
        if ((charsThatFit+offset) == segPtr->size) {
            for (nextPtr = segPtr->nextPtr; nextPtr != NULL;
                    nextPtr = nextPtr->nextPtr) {
                if (nextPtr->size != 0) {
                    if (nextPtr->typePtr != &ckTextCharType) {
                        chunkPtr->breakIndex = chunkPtr->numChars;
                    }
                    break;
                }
            }
        }
    }
    return 1;
}
\f
/*
 *--------------------------------------------------------------
 *
 * CharDisplayProc --
 *
 *      This procedure is called to display a character chunk on
 *      the screen or in an off-screen pixmap.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Graphics are drawn.
 *
 *--------------------------------------------------------------
 */

static void
CharDisplayProc(chunkPtr, x, y, height, baseline, window, screenY)
    CkTextDispChunk *chunkPtr;          /* Chunk that is to be drawn. */
    int x;                              /* X-position in dst at which to
                                         * draw this chunk (may differ from
                                         * the x-position in the chunk because
                                         * of scrolling). */
    int y;                              /* Y-position at which to draw this
                                         * chunk in dst. */
    int height;                         /* Total height of line. */
    int baseline;                       /* Offset of baseline from y. */
    WINDOW *window;
    int screenY;                        /* Y-coordinate in text window that
                                         * corresponds to y. */
{
    CharInfo *ciPtr = (CharInfo *) chunkPtr->clientData;
    Style *stylePtr;
    StyleValues *sValuePtr;

    if ((x + chunkPtr->width) <= 0) {
        /*
         * The chunk is off-screen.
         */

        return;
    }

    stylePtr = chunkPtr->stylePtr;
    sValuePtr = stylePtr->sValuePtr;

    /*
     * Draw the text for this chunk.
     */

    if (ciPtr->numChars > 0) {
        Ck_SetWindowAttr(ciPtr->winPtr, sValuePtr->fg, sValuePtr->bg,
            sValuePtr->attr);
        CkDisplayChars(ciPtr->winPtr->mainPtr, window, ciPtr->chars,
            ciPtr->numChars, x,
            screenY + baseline, x - chunkPtr->x, CK_IGNORE_TABS);
    }
}
\f
/*
 *--------------------------------------------------------------
 *
 * CharUndisplayProc --
 *
 *      This procedure is called when a character chunk is no
 *      longer going to be displayed.  It frees up resources
 *      that were allocated to display the chunk.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Memory and other resources get freed.
 *
 *--------------------------------------------------------------
 */

static void
CharUndisplayProc(textPtr, chunkPtr)
    CkText *textPtr;                    /* Overall information about text
                                         * widget. */
    CkTextDispChunk *chunkPtr;          /* Chunk that is about to be freed. */
{
    CharInfo *ciPtr = (CharInfo *) chunkPtr->clientData;

    ckfree((char *) ciPtr);
}
\f
/*
 *--------------------------------------------------------------
 *
 * CharMeasureProc --
 *
 *      This procedure is called to determine which character in
 *      a character chunk lies over a given x-coordinate.
 *
 * Results:
 *      The return value is the index *within the chunk* of the
 *      character that covers the position given by "x".
 *
 * Side effects:
 *      None.
 *
 *--------------------------------------------------------------
 */

static int
CharMeasureProc(chunkPtr, x)
    CkTextDispChunk *chunkPtr;          /* Chunk containing desired coord. */
    int x;                              /* X-coordinate, in same coordinate
                                         * system as chunkPtr->x. */
{
    CharInfo *ciPtr = (CharInfo *) chunkPtr->clientData;
    int endX, charX;

    CkMeasureChars(ciPtr->winPtr->mainPtr,
            ciPtr->chars, chunkPtr->numChars-1, chunkPtr->x,
            x, 0, CK_IGNORE_TABS, &endX, &charX);
    return charX;
}
\f
/*
 *--------------------------------------------------------------
 *
 * CharBboxProc --
 *
 *      This procedure is called to compute the bounding box of
 *      the area occupied by a single character.
 *
 * Results:
 *      There is no return value.  *xPtr and *yPtr are filled in
 *      with the coordinates of the upper left corner of the
 *      character, and *widthPtr and *heightPtr are filled in with
 *      the dimensions of the character in pixels.  Note:  not all
 *      of the returned bbox is necessarily visible on the screen
 *      (the rightmost part might be off-screen to the right,
 *      and the bottommost part might be off-screen to the bottom).
 *
 * Side effects:
 *      None.
 *
 *--------------------------------------------------------------
 */

static void
CharBboxProc(chunkPtr, index, y, lineHeight, baseline, xPtr, yPtr,
        widthPtr, heightPtr)
    CkTextDispChunk *chunkPtr;          /* Chunk containing desired char. */
    int index;                          /* Index of desired character within
                                         * the chunk. */
    int y;                              /* Topmost pixel in area allocated
                                         * for this line. */
    int lineHeight;                     /* Height of line, in pixels. */
    int baseline;                       /* Location of line's baseline, in
                                         * pixels measured down from y. */
    int *xPtr, *yPtr;                   /* Gets filled in with coords of
                                         * character's upper-left pixel. 
                                         * X-coord is in same coordinate
                                         * system as chunkPtr->x. */
    int *widthPtr;                      /* Gets filled in with width of
                                         * character, in pixels. */
    int *heightPtr;                     /* Gets filled in with height of
                                         * character, in pixels. */
{
    CharInfo *ciPtr = (CharInfo *) chunkPtr->clientData;
    CkWindow *winPtr = ciPtr->winPtr;
    int maxX, dummy;

    maxX = chunkPtr->width + chunkPtr->x;
    CkMeasureChars(winPtr->mainPtr,
        ciPtr->chars, index, chunkPtr->x, 1000000, 0,
        CK_IGNORE_TABS, xPtr, &dummy);
    if (index == ciPtr->numChars) {
        /*
         * This situation only happens if the last character in a line
         * is a space character, in which case it absorbs all of the
         * extra space in the line (see CkTextCharLayoutProc).
         */

        *widthPtr = maxX - *xPtr;
    } else if ((ciPtr->chars[index] == '\t')
            && (index == (ciPtr->numChars-1))) {
        /*
         * The desired character is a tab character that terminates a
         * chunk;  give it all the space left in the chunk.
         */

        *widthPtr = maxX - *xPtr;
    } else {
        CkMeasureChars(winPtr->mainPtr,
            ciPtr->chars + index, 1, *xPtr, 1000000, 0,
            CK_IGNORE_TABS, widthPtr, &dummy);
        if (*widthPtr > maxX) {
            *widthPtr = maxX - *xPtr;
        } else {
            *widthPtr -= *xPtr;
        }
    }
    *yPtr = y + baseline;
    *heightPtr = 1;
}
\f
/*
 *----------------------------------------------------------------------
 *
 * AdjustForTab --
 *
 *      This procedure is called to move a series of chunks right
 *      in order to align them with a tab stop.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The width of chunkPtr gets adjusted so that it absorbs the
 *      extra space due to the tab.  The x locations in all the chunks
 *      after chunkPtr are adjusted rightward to align with the tab
 *      stop given by tabArrayPtr and index.
 *
 *----------------------------------------------------------------------
 */

static void
AdjustForTab(textPtr, tabArrayPtr, index, chunkPtr)
    CkText *textPtr;                    /* Information about the text widget as
                                         * a whole. */
    CkTextTabArray *tabArrayPtr;        /* Information about the tab stops
                                         * that apply to this line.  May be
                                         * NULL to indicate default tabbing
                                         * (every 8 chars). */
    int index;                          /* Index of current tab stop. */
    CkTextDispChunk *chunkPtr;          /* Chunk whose last character is
                                         * the tab;  the following chunks
                                         * contain information to be shifted
                                         * right. */

{
    int x, desired, delta, width, decimal, i, gotDigit;
    CkTextDispChunk *chunkPtr2, *decimalChunkPtr;
    CkTextTab *tabPtr;
    CharInfo *ciPtr = NULL;             /* Initialization needed only to
                                         * prevent compiler warnings. */
    int tabX, prev, spaceWidth, dummy;
    char *p;
    CkTextTabAlign alignment;

    if (chunkPtr->nextPtr == NULL) {
        /*
         * Nothing after the actual tab;  just return.
         */

        return;
    }

    /*
     * If no tab information has been given, do the usual thing:
     * round up to the next boundary of 8 average-sized characters.
     */

    x = chunkPtr->nextPtr->x;
    if ((tabArrayPtr == NULL) || (tabArrayPtr->numTabs == 0)) {
        /*
         * No tab information has been given, so use the default
         * interpretation of tabs.
         */

        CkMeasureChars(textPtr->winPtr->mainPtr,
            "\t", 1, x, INT_MAX, 0, 0, &desired, &dummy);
        goto update;
    }

    if (index < tabArrayPtr->numTabs) {
        alignment = tabArrayPtr->tabs[index].alignment;
        tabX = tabArrayPtr->tabs[index].location;
    } else {
        /*
         * Ran out of tab stops;  compute a tab position by extrapolating
         * from the last two tab positions.
         */

        if (tabArrayPtr->numTabs > 1) {
            prev = tabArrayPtr->tabs[tabArrayPtr->numTabs-2].location;
        } else {
            prev = 0;
        }
        alignment = tabArrayPtr->tabs[tabArrayPtr->numTabs-1].alignment;
        tabX = tabArrayPtr->tabs[tabArrayPtr->numTabs-1].location
                + (index + 1 - tabArrayPtr->numTabs)
                * (tabArrayPtr->tabs[tabArrayPtr->numTabs-1].location - prev);
    }

    tabPtr = &tabArrayPtr->tabs[index];
    if (alignment == LEFT) {
        desired = tabX;
        goto update;
    }

    if ((alignment == CENTER) || (alignment == RIGHT)) {
        /*
         * Compute the width of all the information in the tab group,
         * then use it to pick a desired location.
         */

        width = 0;
        for (chunkPtr2 = chunkPtr->nextPtr; chunkPtr2 != NULL;
                chunkPtr2 = chunkPtr2->nextPtr) {
            width += chunkPtr2->width;
        }
        if (alignment == CENTER) {
            desired = tabX - width/2;
        } else {
            desired = tabX - width;
        }
        goto update;
    }

    /*
     * Must be numeric alignment.  Search through the text to be
     * tabbed, looking for the last , or . before the first character
     * that isn't a number, comma, period, or sign.
     */

    decimalChunkPtr = NULL;
    decimal = gotDigit = 0;
    for (chunkPtr2 = chunkPtr->nextPtr; chunkPtr2 != NULL;
            chunkPtr2 = chunkPtr2->nextPtr) {
        if (chunkPtr2->displayProc != CharDisplayProc) {
            continue;
        }
        ciPtr = (CharInfo *) chunkPtr2->clientData;
        for (p = ciPtr->chars, i = 0; i < ciPtr->numChars; p++, i++) {
            if (isdigit((unsigned char) *p)) {
                gotDigit = 1;
            } else if ((*p == '.') || (*p == ',')) {
                decimal = p-ciPtr->chars;
                decimalChunkPtr = chunkPtr2;
            } else if (gotDigit) {
                if (decimalChunkPtr == NULL) {
                    decimal = p-ciPtr->chars;
                    decimalChunkPtr = chunkPtr2;
                }
                goto endOfNumber;
            }
        }
    }
    endOfNumber:
    if (decimalChunkPtr != NULL) {
        int curX;

        ciPtr = (CharInfo *) decimalChunkPtr->clientData;
        CkMeasureChars(ciPtr->winPtr->mainPtr,
            ciPtr->chars, decimal, decimalChunkPtr->x, 1000000, 0,
            CK_IGNORE_TABS, &curX, &dummy);
        desired = tabX - (curX - x);
        goto update;
    } else {
        /*
         * There wasn't a decimal point.  Right justify the text.
         */
    
        width = 0;
        for (chunkPtr2 = chunkPtr->nextPtr; chunkPtr2 != NULL;
                chunkPtr2 = chunkPtr2->nextPtr) {
            width += chunkPtr2->width;
        }
        desired = tabX - width;
    }

    /*
     * Shift all of the chunks to the right so that the left edge is
     * at the desired location, then expand the chunk containing the
     * tab.  Be sure that the tab occupies at least the width of a
     * space character.
     */

    update:
    delta = desired - x;
    CkMeasureChars(textPtr->winPtr->mainPtr, " ", 1, 0, INT_MAX,
         0, 0, &spaceWidth, &dummy);
    if (delta < spaceWidth) {
        delta = spaceWidth;
    }
    for (chunkPtr2 = chunkPtr->nextPtr; chunkPtr2 != NULL;
            chunkPtr2 = chunkPtr2->nextPtr) {
        chunkPtr2->x += delta;
    }
    chunkPtr->width += delta;
}
\f
/*
 *----------------------------------------------------------------------
 *
 * SizeOfTab --
 *
 *      This returns an estimate of the amount of white space that will
 *      be consumed by a tab.
 *
 * Results:
 *      The return value is the minimum number of pixels that will
 *      be occupied by the index'th tab of tabArrayPtr, assuming that
 *      the current position on the line is x and the end of the
 *      line is maxX.  For numeric tabs, this is a conservative
 *      estimate.  The return value is always >= 0.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static int
SizeOfTab(textPtr, tabArrayPtr, index, x, maxX)
    CkText *textPtr;                    /* Information about the text widget as
                                         * a whole. */
    CkTextTabArray *tabArrayPtr;        /* Information about the tab stops
                                         * that apply to this line.  NULL
                                         * means use default tabbing (every
                                         * 8 chars.) */
    int index;                          /* Index of current tab stop. */
    int x;                              /* Current x-location in line. Only
                                         * used if tabArrayPtr == NULL. */
    int maxX;                           /* X-location of pixel just past the
                                         * right edge of the line. */
{
    int tabX, prev, result, spaceWidth, dummy;
    CkTextTabAlign alignment;
    CkWindow *winPtr = textPtr->winPtr;

    if ((tabArrayPtr == NULL) || (tabArrayPtr->numTabs == 0)) {
        CkMeasureChars(winPtr->mainPtr, "\t", 1, x, INT_MAX,
            0, 0, &tabX, &dummy);
        return tabX - x;
    }
    if (index < tabArrayPtr->numTabs) {
        tabX = tabArrayPtr->tabs[index].location;
        alignment = tabArrayPtr->tabs[index].alignment;
    } else {
        /*
         * Ran out of tab stops;  compute a tab position by extrapolating
         * from the last two tab positions.
         */

        if (tabArrayPtr->numTabs > 1) {
            prev = tabArrayPtr->tabs[tabArrayPtr->numTabs-2].location;
        } else {
            prev = 0;
        }
        tabX = tabArrayPtr->tabs[tabArrayPtr->numTabs-1].location
                + (index + 1 - tabArrayPtr->numTabs)
                * (tabArrayPtr->tabs[tabArrayPtr->numTabs-1].location - prev);
        alignment = tabArrayPtr->tabs[tabArrayPtr->numTabs-1].alignment;
    }
    if (alignment == CENTER) {
        /*
         * Be very careful in the arithmetic below, because maxX may
         * be the largest positive number:  watch out for integer
         * overflow.
         */

        if ((maxX-tabX) < (tabX - x)) {
            result = (maxX - x) - 2*(maxX - tabX);
        } else {
            result = 0;
        }
        goto done;
    }
    if (alignment == RIGHT) {
        result = 0;
        goto done;
    }

    /*
     * Note: this treats NUMERIC alignment the same as LEFT
     * alignment, which is somewhat conservative.  However, it's
     * pretty tricky at this point to figure out exactly where
     * the damn decimal point will be.
     */

    if (tabX > x) {
        result = tabX - x;
    } else {
        result = 0;
    }

    done:
    CkMeasureChars(winPtr->mainPtr, " ", 1, 0, INT_MAX,
        0, 0, &spaceWidth, &dummy);
    if (result < spaceWidth) {
        result = spaceWidth;
    }
    return result;
}