Return to tktxdisp.c CVS log

Up to [Micropolis - Activity] / micropolis / src / tk

Annotation of micropolis/src/tk/tktxdisp.c, revision 1.1

1.1     ! root        1: /* 
        !             2:  * tkTextDisp.c --
        !             3:  *
        !             4:  *     This module provides facilities to display text widgets.  It is
        !             5:  *     the only place where information is kept about the screen layout
        !             6:  *     of text widgets.
        !             7:  *
        !             8:  * Copyright 1992 Regents of the University of California.
        !             9:  * Permission to use, copy, modify, and distribute this
        !            10:  * software and its documentation for any purpose and without
        !            11:  * fee is hereby granted, provided that the above copyright
        !            12:  * notice appear in all copies.  The University of California
        !            13:  * makes no representations about the suitability of this
        !            14:  * software for any purpose.  It is provided "as is" without
        !            15:  * express or implied warranty.
        !            16:  */
        !            17: 
        !            18: #ifndef lint
        !            19: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkTextDisp.c,v 1.20 92/08/24 09:24:18 ouster Exp $ SPRITE (Berkeley)";
        !            20: #endif
        !            21: 
        !            22: #include "tkconfig.h"
        !            23: #include "tkint.h"
        !            24: #include "tktext.h"
        !            25: 
        !            26: #include <assert.h>
        !            27: 
        !            28: /*
        !            29:  * The following structure describes how to display a range of characters.
        !            30:  * The information is generated by scanning all of the tags associated
        !            31:  * with the characters and combining that with default information for
        !            32:  * the overall widget.  These structures form the hash keys for
        !            33:  * dInfoPtr->styleTable.
        !            34:  */
        !            35: 
        !            36: typedef struct StyleValues {
        !            37:     Tk_3DBorder border;                /* Used for drawing background under text.
        !            38:                                 * NULL means use widget background. */
        !            39:     int borderWidth;           /* Width of 3-D border for background. */
        !            40:     int relief;                        /* 3-D relief for background. */
        !            41:     Pixmap bgStipple;          /* Stipple bitmap for background.  None
        !            42:                                 * means draw solid. */
        !            43:     XColor *fgColor;           /* Foreground color for text. */
        !            44:     XFontStruct *fontPtr;      /* Font for displaying text. */
        !            45:     Pixmap fgStipple;          /* Stipple bitmap for text and other
        !            46:                                 * foreground stuff.   None means draw
        !            47:                                 * solid.*/
        !            48:     int underline;             /* Non-zero means draw underline underneath
        !            49:                                 * text. */
        !            50: } StyleValues;
        !            51: 
        !            52: /*
        !            53:  * The following structure extends the StyleValues structure above with
        !            54:  * graphics contexts used to actually draw the characters.  The entries
        !            55:  * in dInfoPtr->styleTable point to structures of this type.
        !            56:  */
        !            57: 
        !            58: typedef struct Style {
        !            59:     int refCount;              /* Number of times this structure is
        !            60:                                 * referenced in Chunks. */
        !            61:     GC bgGC;                   /* Graphics context for background.  None
        !            62:                                 * unless background is stippled. */
        !            63:     GC fgGC;                   /* Graphics context for foreground. */
        !            64:     StyleValues *sValuePtr;    /* Raw information from which GCs were
        !            65:                                 * derived. */
        !            66:     Tcl_HashEntry *hPtr;       /* Pointer to entry in styleTable.  Used
        !            67:                                 * to delete entry. */
        !            68: } Style;
        !            69: 
        !            70: /*
        !            71:  * The following structure describes a range of characters, all on the
        !            72:  * same line of the display (which also means the same line of the text
        !            73:  * widget) and all having the same display attributes.
        !            74:  */
        !            75: 
        !            76: typedef struct Chunk {
        !            77:     char *text;                        /* Characters to display. */
        !            78:     int numChars;              /* Number of characters to display. */
        !            79:     Style *stylePtr;           /* Style information used to display
        !            80:                                 * characters. */
        !            81:     int x;                     /* X-coordinate of pixel at which to display
        !            82:                                 * the characters. */
        !            83:     struct Chunk *nextPtr;     /* Next in list of all chunks displayed on the
        !            84:                                 * same display line. */
        !            85: } Chunk;
        !            86: 
        !            87: /*
        !            88:  * The following structure describes one line of the display, which may
        !            89:  * be either part or all of one line of the text.
        !            90:  */
        !            91: 
        !            92: typedef struct DLine {
        !            93:     TkTextLine *linePtr;       /* Pointer to structure in B-tree that
        !            94:                                 * contains characters displayed in this
        !            95:                                 * line. */
        !            96:     int y;                     /* Y-position at which line is supposed to
        !            97:                                 * be drawn (topmost pixel of rectangular
        !            98:                                 * area occupied by line). */
        !            99:     int oldY;                  /* Y-position at which line currently
        !           100:                                 * appears on display.  -1 means line isn't
        !           101:                                 * currently visible on display.  This is
        !           102:                                 * used to move lines by scrolling rather
        !           103:                                 * than re-drawing. */
        !           104:     int height;                        /* Height of line, in pixels. */
        !           105:     int baseline;              /* Offset of text baseline from y. */
        !           106:     Chunk *chunkPtr;           /* Pointer to first chunk in list of all
        !           107:                                 * of those that are displayed on this
        !           108:                                 * line of the screen. */
        !           109:     struct DLine *nextPtr;     /* Next in list of all display lines for
        !           110:                                 * this window.   The list is sorted in
        !           111:                                 * order from top to bottom.  Note:  the
        !           112:                                 * next DLine doesn't always correspond
        !           113:                                 * to the next line of text:  (a) can have
        !           114:                                 * multiple DLines for one text line, and
        !           115:                                 * (b) can have gaps where DLine's have been
        !           116:                                 * deleted because they're out of date. */
        !           117: } DLine;
        !           118: 
        !           119: /*
        !           120:  * Overall display information for a text widget:
        !           121:  */
        !           122: 
        !           123: typedef struct DInfo {
        !           124:     Tcl_HashTable styleTable;  /* Hash table that maps from StyleValues to
        !           125:                                 * Styles for this widget. */
        !           126:     DLine *dLinePtr;           /* First in list of all display lines for
        !           127:                                 * this widget, in order from top to bottom. */
        !           128:     GC copyGC;                 /* Graphics context for copying from off-
        !           129:                                 * screen pixmaps onto screen. */
        !           130:     GC scrollGC;               /* Graphics context for copying from one place
        !           131:                                 * in the window to another (scrolling):
        !           132:                                 * differs from copyGC in that we need to get
        !           133:                                 * GraphicsExpose events. */
        !           134:     int x;                     /* First x-coordinate that may be used for
        !           135:                                 * actually displaying line information.
        !           136:                                 * Leaves space for border, etc. */
        !           137:     int y;                     /* First y-coordinate that may be used for
        !           138:                                 * actually displaying line information.
        !           139:                                 * Leaves space for border, etc. */
        !           140:     int maxX;                  /* First x-coordinate to right of available
        !           141:                                 * space for displaying lines. */
        !           142:     int maxY;                  /* First y-coordinate to bottom of available
        !           143:                                 * space for displaying lines. */
        !           144:     int topOfEof;              /* Top-most pixel (lowest y-value) that has
        !           145:                                 * been drawn in the appropriate fashion for
        !           146:                                 * the portion of the window after the last
        !           147:                                 * line of the text.  This field is used to
        !           148:                                 * figure out when to redraw part or all of
        !           149:                                 * the eof field. */
        !           150:     int flags;                 /* Various flag values:  see below for
        !           151:                                 * definitions. */
        !           152: } DInfo;
        !           153: 
        !           154: /*
        !           155:  * Flag values for DInfo structures:
        !           156:  *
        !           157:  * DINFO_OUT_OF_DATE:          Non-zero means that the DLine structures
        !           158:  *                             for this window are partially or completely
        !           159:  *                             out of date and need to be recomputed.
        !           160:  * REDRAW_PENDING:             Means that a when-idle handler has been
        !           161:  *                             scheduled to update the display.
        !           162:  * REDRAW_BORDERS:             Means window border or pad area has
        !           163:  *                             potentially been damaged and must be redrawn.
        !           164:  * REPICK_NEEDED:              1 means that the widget has been modified
        !           165:  *                             in a way that could change the current
        !           166:  *                             character (a different character might be
        !           167:  *                             under the mouse cursor now).  Need to
        !           168:  *                             recompute the current character before
        !           169:  *                             the next redisplay.
        !           170:  */
        !           171: 
        !           172: #define DINFO_OUT_OF_DATE      1
        !           173: #define REDRAW_PENDING         2
        !           174: #define REDRAW_BORDERS         4
        !           175: #define REPICK_NEEDED          8
        !           176: 
        !           177: /*
        !           178:  * Structures of the type defined below are used to keep track of
        !           179:  * tags while scanning through the text to create DLine structures.
        !           180:  */
        !           181: 
        !           182: typedef struct TagInfo {
        !           183:     int numTags;               /* Number of tags currently active (the first
        !           184:                                 * entries at *tagPtr). */
        !           185:     int arraySize;             /* Total number of entries at *tagPtr.  We
        !           186:                                 * over-allocate the array to avoid continual
        !           187:                                 * reallocations. */
        !           188:     TkTextTag **tagPtrs;       /* Pointer to array of pointers to active tags.
        !           189:                                 * Array has space for arraySize tags, and
        !           190:                                 * the first numTags are slots identify the
        !           191:                                 * active tags. Malloc'ed (but may be NULL). */
        !           192:     TkTextSearch search;       /* Used to scan for tag transitions.  Current
        !           193:                                 * state identifies next tag transition. */
        !           194: } TagInfo;
        !           195: 
        !           196: /*
        !           197:  * The following counters keep statistics about redisplay that can be
        !           198:  * checked to see how clever this code is at reducing redisplays.
        !           199:  */
        !           200: 
        !           201: static int numRedisplays;      /* Number of calls to DisplayText. */
        !           202: static int linesRedrawn;       /* Number of calls to DisplayDLine. */
        !           203: static int numCopies;          /* Number of calls to XCopyArea to copy part
        !           204:                                 * of the screen. */
        !           205: static int damagedCopies;      /* Number of times that XCopyAreas didn't
        !           206:                                 * completely work because some of the source
        !           207:                                 * information was damaged. */
        !           208: static int TextUpdateTime = 100; // Added by Don.
        !           209: 
        !           210: /*
        !           211:  * Forward declarations for procedures defined later in this file:
        !           212:  */
        !           213: 
        !           214: static void            ComputeStyleValues _ANSI_ARGS_((TkText *textPtr,
        !           215:                            int numTags, TkTextTag **tagPtr,
        !           216:                            StyleValues *sValuePtr));
        !           217: static void            DisplayDLine _ANSI_ARGS_((TkText *textPtr,
        !           218:                            DLine *dlPtr, Pixmap pixmap));
        !           219: static void            DisplayText _ANSI_ARGS_((ClientData clientData));
        !           220: static DLine *         FindDLine _ANSI_ARGS_((DLine *dlPtr, int line));
        !           221: static void            FreeDLines _ANSI_ARGS_((TkText *textPtr,
        !           222:                            DLine *firstPtr, DLine *lastPtr, int unlink));
        !           223: static void            FreeStyle _ANSI_ARGS_((Style *stylePtr));
        !           224: static Style *         GetStyle _ANSI_ARGS_((TkText *textPtr,
        !           225:                            StyleValues *sValuePtr));
        !           226: static DLine *         LayoutLine _ANSI_ARGS_((TkText *textPtr, int line,
        !           227:                            TkTextLine *linePtr, TagInfo *tInfoPtr));
        !           228: static void            ToggleTag _ANSI_ARGS_((TagInfo *tInfoPtr,
        !           229:                            TkTextTag *tagPtr));
        !           230: static void            UpdateDisplayInfo _ANSI_ARGS_((TkText *textPtr));
        !           231: 
        !           232: /*
        !           233:  *----------------------------------------------------------------------
        !           234:  *
        !           235:  * TkTextCreateDInfo --
        !           236:  *
        !           237:  *     This procedure is called when a new text widget is created.
        !           238:  *     Its job is to set up display-related information for the widget.
        !           239:  *
        !           240:  * Results:
        !           241:  *     None.
        !           242:  *
        !           243:  * Side effects:
        !           244:  *     A DInfo data structure is allocated and initialized and attached
        !           245:  *     to textPtr.
        !           246:  *
        !           247:  *----------------------------------------------------------------------
        !           248:  */
        !           249: 
        !           250: void
        !           251: TkTextCreateDInfo(textPtr)
        !           252:     TkText *textPtr;           /* Overall information for text widget. */
        !           253: {
        !           254:     register DInfo *dInfoPtr;
        !           255:     XGCValues gcValues;
        !           256: 
        !           257:     dInfoPtr = (DInfo *) ckalloc(sizeof(DInfo));
        !           258:     Tcl_InitHashTable(&dInfoPtr->styleTable, sizeof(StyleValues)/sizeof(int));
        !           259:     dInfoPtr->dLinePtr = NULL;
        !           260:     gcValues.graphics_exposures = False;
        !           261:     dInfoPtr->copyGC = Tk_GetGC(textPtr->tkwin, GCGraphicsExposures, &gcValues);
        !           262:     gcValues.graphics_exposures = True;
        !           263:     dInfoPtr->scrollGC = Tk_GetGC(textPtr->tkwin, GCGraphicsExposures,
        !           264:            &gcValues);
        !           265:     dInfoPtr->topOfEof = 0;
        !           266:     dInfoPtr->flags = DINFO_OUT_OF_DATE;
        !           267:     textPtr->dInfoPtr = dInfoPtr;
        !           268: }
        !           269: 
        !           270: /*
        !           271:  *----------------------------------------------------------------------
        !           272:  *
        !           273:  * TkTextFreeDInfo --
        !           274:  *
        !           275:  *     This procedure is called to free up all of the private display
        !           276:  *     information kept by this file for a text widget.
        !           277:  *
        !           278:  * Results:
        !           279:  *     None.
        !           280:  *
        !           281:  * Side effects:
        !           282:  *     Lots of resources get freed.
        !           283:  *
        !           284:  *----------------------------------------------------------------------
        !           285:  */
        !           286: 
        !           287: void
        !           288: TkTextFreeDInfo(textPtr)
        !           289:     TkText *textPtr;           /* Overall information for text widget. */
        !           290: {
        !           291:     register DInfo *dInfoPtr = textPtr->dInfoPtr;
        !           292: 
        !           293:     /*
        !           294:      * Be careful to free up styleTable *after* freeing up all the
        !           295:      * DLines, so that the hash table is still intact to free up the
        !           296:      * style-related information from the lines.  Once the lines are
        !           297:      * all free then styleTable will be empty.
        !           298:      */
        !           299: 
        !           300:     FreeDLines(textPtr, dInfoPtr->dLinePtr, (DLine *) NULL, 1);
        !           301:     Tcl_DeleteHashTable(&dInfoPtr->styleTable);
        !           302:     Tk_FreeGC(dInfoPtr->copyGC);
        !           303:     Tk_FreeGC(dInfoPtr->scrollGC);
        !           304:     if (dInfoPtr->flags & REDRAW_PENDING) {
        !           305: //     Tk_CancelIdleCall(DisplayText, (ClientData) textPtr);
        !           306:         assert(textPtr->updateTimerToken != NULL);
        !           307:        if (textPtr->updateTimerToken != NULL) {
        !           308:            Tk_DeleteTimerHandler(textPtr->updateTimerToken);
        !           309:            textPtr->updateTimerToken = NULL;
        !           310:        }
        !           311:     }
        !           312:     ckfree((char *) dInfoPtr);
        !           313: }
        !           314: 
        !           315: /*
        !           316:  *----------------------------------------------------------------------
        !           317:  *
        !           318:  * GetStyle --
        !           319:  *
        !           320:  *     This procedure creates graphics contexts needed to display
        !           321:  *     text in a particular style, determined by "sValuePtr".  It
        !           322:  *     attempts to share style information as much as possible.
        !           323:  *
        !           324:  * Results:
        !           325:  *     The return value is a pointer to a Style structure that
        !           326:  *     corresponds to *sValuePtr.
        !           327:  *
        !           328:  * Side effects:
        !           329:  *     A new entry may be created in the style table for the widget.
        !           330:  *
        !           331:  *----------------------------------------------------------------------
        !           332:  */
        !           333: 
        !           334: static Style *
        !           335: GetStyle(textPtr, sValuePtr)
        !           336:     TkText *textPtr;           /* Overall information about text widget. */
        !           337:     StyleValues *sValuePtr;    /* Information about desired style. */
        !           338: {
        !           339:     Style *stylePtr;
        !           340:     Tcl_HashEntry *hPtr;
        !           341:     int new;
        !           342:     XGCValues gcValues;
        !           343:     unsigned long mask;
        !           344: 
        !           345:     /*
        !           346:      * Use an existing style if there's one around that matches.
        !           347:      */
        !           348: 
        !           349:     hPtr = Tcl_CreateHashEntry(&textPtr->dInfoPtr->styleTable,
        !           350:            (char *) sValuePtr, &new);
        !           351:     if (!new) {
        !           352:        stylePtr = (Style *) Tcl_GetHashValue(hPtr);
        !           353:        stylePtr->refCount++;
        !           354:        return stylePtr;
        !           355:     }
        !           356: 
        !           357:     /*
        !           358:      * No existing style matched.  Make a new one.
        !           359:      */
        !           360: 
        !           361:     stylePtr = (Style *) ckalloc(sizeof(Style));
        !           362:     stylePtr->refCount = 1;
        !           363:     if ((sValuePtr->border != NULL) && (sValuePtr->bgStipple != None)) {
        !           364:        gcValues.foreground = Tk_3DBorderColor(sValuePtr->border)->pixel;
        !           365:        gcValues.stipple = sValuePtr->bgStipple;
        !           366:        gcValues.fill_style = FillStippled;
        !           367:        stylePtr->bgGC = Tk_GetGC(textPtr->tkwin,
        !           368:                GCForeground|GCStipple|GCFillStyle, &gcValues);
        !           369:     } else {
        !           370:        stylePtr->bgGC = None;
        !           371:     }
        !           372:     mask = GCForeground|GCFont;
        !           373:     gcValues.foreground = sValuePtr->fgColor->pixel;
        !           374:     gcValues.font = sValuePtr->fontPtr->fid;
        !           375:     if (sValuePtr->fgStipple != None) {
        !           376:        gcValues.stipple = sValuePtr->fgStipple;
        !           377:        gcValues.fill_style = FillStippled;
        !           378:        mask |= GCStipple|GCFillStyle;
        !           379:     }
        !           380:     stylePtr->fgGC = Tk_GetGC(textPtr->tkwin, mask, &gcValues);
        !           381:     stylePtr->sValuePtr = (StyleValues *)
        !           382:            Tcl_GetHashKey(&textPtr->dInfoPtr->styleTable, hPtr);
        !           383:     stylePtr->hPtr = hPtr;
        !           384:     Tcl_SetHashValue(hPtr, stylePtr);
        !           385:     return stylePtr;
        !           386: }
        !           387: 
        !           388: /*
        !           389:  *----------------------------------------------------------------------
        !           390:  *
        !           391:  * FreeStyle --
        !           392:  *
        !           393:  *     This procedure is called when a Style structure is no longer
        !           394:  *     needed.  It decrements the reference count and frees up the
        !           395:  *     space for the style structure if the reference count is 0.
        !           396:  *
        !           397:  * Results:
        !           398:  *     None.
        !           399:  *
        !           400:  * Side effects:
        !           401:  *     The storage and other resources associated with the style
        !           402:  *     are freed up if no-one's still using it.
        !           403:  *
        !           404:  *----------------------------------------------------------------------
        !           405:  */
        !           406: 
        !           407: static void
        !           408: FreeStyle(stylePtr)
        !           409:     register Style *stylePtr;  /* Information about style to be freed. */
        !           410: 
        !           411: {
        !           412:     stylePtr->refCount--;
        !           413:     if (stylePtr->refCount == 0) {
        !           414:        if (stylePtr->bgGC != None) {
        !           415:            Tk_FreeGC(stylePtr->bgGC);
        !           416:        }
        !           417:        Tk_FreeGC(stylePtr->fgGC);
        !           418:        Tcl_DeleteHashEntry(stylePtr->hPtr);
        !           419:        ckfree((char *) stylePtr);
        !           420:     }
        !           421: }
        !           422: 
        !           423: /*
        !           424:  *----------------------------------------------------------------------
        !           425:  *
        !           426:  * ComputeStyleValues --
        !           427:  *
        !           428:  *     Given a list of tags that apply at a particular point, compute
        !           429:  *     the StyleValues that correspond to that set of tags.
        !           430:  *
        !           431:  * Results:
        !           432:  *     All of the fields of *sValuePtr get filled in to hold the
        !           433:  *     appropriate display information for the given set of tags
        !           434:  *     in the given widget.
        !           435:  *
        !           436:  * Side effects:
        !           437:  *     None.
        !           438:  *
        !           439:  *----------------------------------------------------------------------
        !           440:  */
        !           441: 
        !           442: static void
        !           443: ComputeStyleValues(textPtr, numTags, tagPtrPtr, sValuePtr)
        !           444:     TkText *textPtr;                   /* Overall information for widget. */
        !           445:     int numTags;                       /* Number of tags at *tagPtr. */
        !           446:     register TkTextTag **tagPtrPtr;    /* Pointer to array of tag pointers. */
        !           447:     register StyleValues *sValuePtr;   /* Pointer to structure to fill in. */
        !           448: {
        !           449:     register TkTextTag *tagPtr;
        !           450: 
        !           451:     /*
        !           452:      * The variables below keep track of the highest-priority specification
        !           453:      * that has occurred for each of the various fields of the StyleValues.
        !           454:      */
        !           455: 
        !           456:     int borderPrio, bgStipplePrio;
        !           457:     int fgPrio, fontPrio, fgStipplePrio;
        !           458: 
        !           459:     borderPrio = bgStipplePrio = -1;
        !           460:     fgPrio = fontPrio = fgStipplePrio = -1;
        !           461:     memset((VOID *) sValuePtr, 0, sizeof(StyleValues));
        !           462:     sValuePtr->fgColor = textPtr->fgColor;
        !           463:     sValuePtr->fontPtr = textPtr->fontPtr;
        !           464: 
        !           465:     /*
        !           466:      * Scan through all of the tags, updating the StyleValues to hold
        !           467:      * the highest-priority information.
        !           468:      */
        !           469: 
        !           470:     for ( ; numTags > 0; tagPtrPtr++, numTags--) {
        !           471:        tagPtr = *tagPtrPtr;
        !           472:        if ((tagPtr->border != NULL) && (tagPtr->priority > borderPrio)) {
        !           473:            sValuePtr->border = tagPtr->border;
        !           474:            sValuePtr->borderWidth = tagPtr->borderWidth;
        !           475:            sValuePtr->relief = tagPtr->relief;
        !           476:            borderPrio = tagPtr->priority;
        !           477:        }
        !           478:        if ((tagPtr->bgStipple != None)
        !           479:                && (tagPtr->priority > bgStipplePrio)) {
        !           480:            sValuePtr->bgStipple = tagPtr->bgStipple;
        !           481:            bgStipplePrio = tagPtr->priority;
        !           482:        }
        !           483:        if ((tagPtr->fgColor != None) && (tagPtr->priority > fgPrio)) {
        !           484:            sValuePtr->fgColor = tagPtr->fgColor;
        !           485:            fgPrio = tagPtr->priority;
        !           486:        }
        !           487:        if ((tagPtr->fontPtr != None) && (tagPtr->priority > fontPrio)) {
        !           488:            sValuePtr->fontPtr = tagPtr->fontPtr;
        !           489:            fontPrio = tagPtr->priority;
        !           490:        }
        !           491:        if ((tagPtr->fgStipple != None)
        !           492:                && (tagPtr->priority > fgStipplePrio)) {
        !           493:            sValuePtr->fgStipple = tagPtr->fgStipple;
        !           494:            fgStipplePrio = tagPtr->priority;
        !           495:        }
        !           496:        if (tagPtr->underline) {
        !           497:            sValuePtr->underline = 1;
        !           498:        }
        !           499:     }
        !           500: }
        !           501: 
        !           502: /*
        !           503:  *----------------------------------------------------------------------
        !           504:  *
        !           505:  * LayoutLine --
        !           506:  *
        !           507:  *     This procedure generates a linked list of one or more DLine
        !           508:  *     structures, which describe how to display everything in one
        !           509:  *     line of the text.
        !           510:  *
        !           511:  * Results:
        !           512:  *     The return value is a pointer to one or more DLine structures
        !           513:  *     linked into a linked list.  The structures are completely filled
        !           514:  *     in except for the y field, which the caller must supply.  Also,
        !           515:  *     the information at *tInfoPtr gets updated to refer to the state
        !           516:  *     just after the last character of the line.
        !           517:  *
        !           518:  * Side effects:
        !           519:  *     None.
        !           520:  *
        !           521:  *----------------------------------------------------------------------
        !           522:  */
        !           523: 
        !           524: static DLine *
        !           525: LayoutLine(textPtr, line, linePtr, tInfoPtr)
        !           526:     TkText *textPtr;           /* Overall information about text widget. */
        !           527:     int line;                  /* Index of line to layout. */
        !           528:     TkTextLine *linePtr;       /* Line to layout (corresponds to line). */
        !           529:     TagInfo *tInfoPtr;         /* Information to help keep track of tags.
        !           530:                                 * Caller must have initialized to correspond
        !           531:                                 * to state just before start of line. */
        !           532: {
        !           533:     DLine *firstLinePtr;
        !           534:     DLine *lastLinePtr = NULL; /* Initializations needed only to stop */
        !           535:     Chunk *lastChunkPtr = NULL;        /* compiler warnings. */
        !           536:     register DLine *dlPtr;
        !           537:     register Chunk *chunkPtr;
        !           538:     StyleValues styleValues;
        !           539:     int ch, charsThatFit, ascent, descent, x, maxX;
        !           540: 
        !           541:     firstLinePtr = NULL;
        !           542: 
        !           543:     /*
        !           544:      * Each iteration of the loop below creates one DLine structure.
        !           545:      */
        !           546: 
        !           547:     ch = 0;
        !           548:     while (1) {
        !           549: 
        !           550:        /*
        !           551:         * Create and initialize a new DLine structure.
        !           552:         */
        !           553: 
        !           554:        dlPtr = (DLine *) ckalloc(sizeof(DLine));
        !           555:        dlPtr->linePtr = linePtr;
        !           556:        dlPtr->y = 0;
        !           557:        dlPtr->oldY = -1;
        !           558:        dlPtr->chunkPtr = NULL;
        !           559:        dlPtr->nextPtr = NULL;
        !           560:        if (firstLinePtr == NULL) {
        !           561:            firstLinePtr = dlPtr;
        !           562:        } else {
        !           563:            lastLinePtr->nextPtr = dlPtr;
        !           564:        }
        !           565:        lastLinePtr = dlPtr;
        !           566: 
        !           567:        /*
        !           568:         * Each iteration of the loop below creates one Chunk for the
        !           569:         * new display line.
        !           570:         */
        !           571: 
        !           572:        x = textPtr->dInfoPtr->x;
        !           573:        maxX = textPtr->dInfoPtr->maxX;
        !           574:        ascent = descent = 0;
        !           575:        while (x < maxX) {
        !           576:            chunkPtr = (Chunk *) ckalloc(sizeof(Chunk));
        !           577:            chunkPtr->numChars = linePtr->numBytes - ch;
        !           578:            chunkPtr->text = linePtr->bytes + ch;
        !           579:            chunkPtr->x = x;
        !           580:            chunkPtr->nextPtr = NULL;
        !           581:            if (dlPtr->chunkPtr == NULL) {
        !           582:                dlPtr->chunkPtr = chunkPtr;
        !           583:            } else {
        !           584:                lastChunkPtr->nextPtr = chunkPtr;
        !           585:            }
        !           586:            lastChunkPtr = chunkPtr;
        !           587: 
        !           588:            /*
        !           589:             * Update the tag array to include any tag transitions up
        !           590:             * through the current position, then find the next position
        !           591:             * with a transition on a tag that impacts the way things are
        !           592:             * displayed.
        !           593:             */
        !           594: 
        !           595:            while (1) {
        !           596:                int affectsDisplay;
        !           597:                TkTextTag *tagPtr;
        !           598: 
        !           599:                if ((tInfoPtr->search.linePtr == NULL)
        !           600:                        || (tInfoPtr->search.line1 > line)) {
        !           601:                    break;
        !           602:                }
        !           603:                tagPtr = tInfoPtr->search.tagPtr;
        !           604:                affectsDisplay = TK_TAG_AFFECTS_DISPLAY(tagPtr);
        !           605:                if ((tInfoPtr->search.line1 < line)
        !           606:                        || (tInfoPtr->search.ch1 <= ch)) {
        !           607:                    if (affectsDisplay) {
        !           608:                        ToggleTag(tInfoPtr, tagPtr);
        !           609:                    }
        !           610:                } else {
        !           611:                    if (affectsDisplay) {
        !           612:                        chunkPtr->numChars = tInfoPtr->search.ch1 - ch;
        !           613:                        break;
        !           614:                    }
        !           615:                }
        !           616:                (void) TkBTreeNextTag(&tInfoPtr->search);
        !           617:            }
        !           618: 
        !           619:            /*
        !           620:             * Create style information for this chunk.
        !           621:             */
        !           622: 
        !           623:            ComputeStyleValues(textPtr, tInfoPtr->numTags, tInfoPtr->tagPtrs,
        !           624:                    &styleValues);
        !           625:            chunkPtr->stylePtr = GetStyle(textPtr, &styleValues);
        !           626: 
        !           627:            /*
        !           628:             * See how many characters will fit on the line.  If they don't
        !           629:             * all fit, then a number of compensations may have to be made.
        !           630:             *
        !           631:             * 1. Make sure that at least one character is displayed on
        !           632:             *    each line.
        !           633:             * 2. In wrap mode "none", allow a partial character to be
        !           634:             *    displayed at the end of an incomplete line.
        !           635:             * 3. In wrap mode "word", search back to find the last space
        !           636:             *    character, and terminate the line just after that space
        !           637:             *    character.  This involves a couple of extra complexities:
        !           638:             *        - the last space may be several chunks back;  in this
        !           639:             *          case, delete all the chunks that are after the
        !           640:             *          space.
        !           641:             *        - if no words fit at all, then use character-wrap for
        !           642:             *          this DLine.
        !           643:             *        - have to reinitialize the tag search information, since
        !           644:             *          we may back up over tag toggles (they'll need to be
        !           645:             *          reconsidered on the next DLine).
        !           646:             */
        !           647: 
        !           648:            charsThatFit = TkMeasureChars(styleValues.fontPtr,
        !           649:                    chunkPtr->text, chunkPtr->numChars, chunkPtr->x,
        !           650:                    maxX, 0, &x);
        !           651:            if ((charsThatFit < chunkPtr->numChars) || (x >= maxX)) {
        !           652:                x = maxX;
        !           653:                chunkPtr->numChars = charsThatFit;
        !           654:                ch += charsThatFit;
        !           655:                if (ch < (linePtr->numBytes - 1)) {
        !           656:                    if ((charsThatFit == 0) && (chunkPtr == dlPtr->chunkPtr)) {
        !           657:                        chunkPtr->numChars = 1;
        !           658:                        ch++;
        !           659:                    } else if (textPtr->wrapMode == tkTextWordUid) {
        !           660:                        if (isspace(chunkPtr->text[charsThatFit])) {
        !           661:                            ch += 1;    /* Include space on this line. */
        !           662:                        } else {
        !           663:                            register Chunk *chunkPtr2;
        !           664:                            register char *p;
        !           665:                            Chunk *spaceChunkPtr;
        !           666:                            int count, space;
        !           667: 
        !           668:                            spaceChunkPtr = NULL;
        !           669:                            space = 0;
        !           670:                            for (chunkPtr2 = dlPtr->chunkPtr;
        !           671:                                    chunkPtr2 != NULL;
        !           672:                                    chunkPtr2 = chunkPtr2->nextPtr) {
        !           673:                                for (count = chunkPtr2->numChars - 1,
        !           674:                                        p = chunkPtr2->text + count;
        !           675:                                        count >= 0; count--, p--) {
        !           676:                                    if (isspace(*p)) {
        !           677:                                        spaceChunkPtr = chunkPtr2;
        !           678:                                        space = count;
        !           679:                                        break;
        !           680:                                    }
        !           681:                                }
        !           682:                            }
        !           683:                            if (spaceChunkPtr != NULL) {
        !           684:                                spaceChunkPtr->numChars = space;
        !           685:                                ch = (spaceChunkPtr->text + space + 1)
        !           686:                                        - linePtr->bytes;
        !           687:                                if (chunkPtr != spaceChunkPtr) {
        !           688:                                    chunkPtr = spaceChunkPtr;
        !           689:                                    if (tInfoPtr->tagPtrs != NULL) {
        !           690:                                        ckfree((char *) tInfoPtr->tagPtrs);
        !           691:                                    }
        !           692:                                    tInfoPtr->tagPtrs = TkBTreeGetTags(
        !           693:                                            textPtr->tree, dlPtr->linePtr, ch,
        !           694:                                            &tInfoPtr->numTags);
        !           695:                                    TkBTreeStartSearch(textPtr->tree, line,
        !           696:                                            ch+1,
        !           697:                                            TkBTreeNumLines(textPtr->tree), 0,
        !           698:                                            (TkTextTag *) NULL,
        !           699:                                            &tInfoPtr->search);
        !           700:                                    (void) TkBTreeNextTag(&tInfoPtr->search);
        !           701:                                    tInfoPtr->arraySize = tInfoPtr->numTags;
        !           702:                                    while (chunkPtr->nextPtr != NULL) {
        !           703:                                        chunkPtr2 = chunkPtr->nextPtr;
        !           704:                                        chunkPtr->nextPtr = chunkPtr2->nextPtr;
        !           705:                                        FreeStyle(chunkPtr2->stylePtr);
        !           706:                                        ckfree((char *) chunkPtr2);
        !           707:                                    }
        !           708:                                }
        !           709:                            }
        !           710:                        }
        !           711:                    } else if (textPtr->wrapMode == tkTextNoneUid) {
        !           712:                        chunkPtr->numChars++;
        !           713:                        ch++;
        !           714:                    }
        !           715:                }
        !           716:            } else {
        !           717:                ch += chunkPtr->numChars;
        !           718:            }
        !           719: 
        !           720:            /*
        !           721:             * Update height information for use later in computing
        !           722:             * line's overall height and baseline.
        !           723:             */
        !           724: 
        !           725:            if (styleValues.fontPtr->ascent > ascent) {
        !           726:                ascent = styleValues.fontPtr->ascent;
        !           727:            }
        !           728:            if (styleValues.fontPtr->descent > descent) {
        !           729:                descent = styleValues.fontPtr->descent;
        !           730:            }
        !           731:        }
        !           732: 
        !           733:        dlPtr->height = ascent + descent;
        !           734:        dlPtr->baseline = ascent;
        !           735: 
        !           736:        /*
        !           737:         * Quit when every character but the last character (the newline)
        !           738:         * has been accounted for.  Also quit if the wrap mode is "none":
        !           739:         * this ignores all the characters that don't fit on the first
        !           740:         * line.
        !           741:         */
        !           742: 
        !           743:        if ((ch >= (linePtr->numBytes-1))
        !           744:                || (textPtr->wrapMode == tkTextNoneUid)) {
        !           745:            break;
        !           746:        }
        !           747:     }
        !           748:     return firstLinePtr;
        !           749: }
        !           750: 
        !           751: /*
        !           752:  *----------------------------------------------------------------------
        !           753:  *
        !           754:  * ToggleTag --
        !           755:  *
        !           756:  *     Update information about tags to reflect a transition on a
        !           757:  *     particular tag.
        !           758:  *
        !           759:  * Results:
        !           760:  *     The array at *tInfoPtr is modified to include tagPtr if it
        !           761:  *     didn't already or to exclude it if it used to include it.
        !           762:  *     The array will be reallocated to a larger size if needed.
        !           763:  *
        !           764:  * Side effects:
        !           765:  *     None.
        !           766:  *
        !           767:  *----------------------------------------------------------------------
        !           768:  */
        !           769: 
        !           770: static void
        !           771: ToggleTag(tInfoPtr, tagPtr)
        !           772:     register TagInfo *tInfoPtr;                /* Tag information to be updated. */
        !           773:     TkTextTag *tagPtr;                 /* Tag to be toggled into or out of
        !           774:                                         * *tInfoPtr. */
        !           775: {
        !           776:     register TkTextTag **tagPtrPtr;
        !           777:     int i;
        !           778: 
        !           779:     for (i = tInfoPtr->numTags, tagPtrPtr = tInfoPtr->tagPtrs;
        !           780:            i > 0; i--, tagPtrPtr++) {
        !           781:        if (*tagPtrPtr == tagPtr) {
        !           782:            tInfoPtr->numTags--;
        !           783:            *tagPtrPtr = tInfoPtr->tagPtrs[tInfoPtr->numTags];
        !           784:            return;
        !           785:        }
        !           786:     }
        !           787: 
        !           788:     /*
        !           789:      * Tag not currently in array.  Grow the array if necessary, then
        !           790:      * add the tag to it.
        !           791:      */
        !           792: 
        !           793:     if (tInfoPtr->numTags == tInfoPtr->arraySize) {
        !           794:        TkTextTag **newPtrs;
        !           795: 
        !           796:        newPtrs = (TkTextTag **) ckalloc((unsigned)
        !           797:                ((tInfoPtr->arraySize+10) * sizeof(TkTextTag *)));
        !           798:        if (tInfoPtr->tagPtrs != NULL) {
        !           799:            memcpy((VOID *) newPtrs, (VOID *) tInfoPtr->tagPtrs,
        !           800:                    tInfoPtr->arraySize * sizeof(TkTextTag *));
        !           801:            ckfree((char *) tInfoPtr->tagPtrs);
        !           802:        }
        !           803:        tInfoPtr->tagPtrs = newPtrs;
        !           804:        tInfoPtr->arraySize += 10;
        !           805:     }
        !           806:     tInfoPtr->tagPtrs[tInfoPtr->numTags] = tagPtr;
        !           807:     tInfoPtr->numTags++;
        !           808: }
        !           809: 
        !           810: /*
        !           811:  *----------------------------------------------------------------------
        !           812:  *
        !           813:  * UpdateDisplayInfo --
        !           814:  *
        !           815:  *     This procedure is invoked to recompute some or all of the
        !           816:  *     DLine structures for a text widget.  At the time it is called
        !           817:  *     the DLine structures still left in the widget are guaranteed
        !           818:  *     to be correct (except for their y-coordinates), but there may
        !           819:  *     be missing structures (the DLine structures get removed as
        !           820:  *     soon as they are potentially out-of-date).
        !           821:  *
        !           822:  * Results:
        !           823:  *     None.
        !           824:  *
        !           825:  * Side effects:
        !           826:  *     Upon return, the DLine information for textPtr correctly reflects
        !           827:  *     the positions where characters will be displayed.  However, this
        !           828:  *     procedure doesn't actually bring the display up-to-date.
        !           829:  *
        !           830:  *----------------------------------------------------------------------
        !           831:  */
        !           832: 
        !           833: static void
        !           834: UpdateDisplayInfo(textPtr)
        !           835:     TkText *textPtr;           /* Text widget to update. */
        !           836: {
        !           837:     register DInfo *dInfoPtr = textPtr->dInfoPtr;
        !           838:     register DLine *dlPtr, *prevPtr, *dlPtr2;
        !           839:     TkTextLine *linePtr;
        !           840:     TagInfo tagInfo;
        !           841:     int line, y, maxY;
        !           842: 
        !           843:     if (!(dInfoPtr->flags & DINFO_OUT_OF_DATE)) {
        !           844:        return;
        !           845:     }
        !           846:     dInfoPtr->flags &= ~DINFO_OUT_OF_DATE;
        !           847: 
        !           848:     linePtr = textPtr->topLinePtr;
        !           849:     dlPtr = dInfoPtr->dLinePtr;
        !           850:     tagInfo.tagPtrs = TkBTreeGetTags(textPtr->tree, linePtr, 0,
        !           851:            &tagInfo.numTags);
        !           852:     tagInfo.arraySize = tagInfo.numTags;
        !           853: 
        !           854:     /*
        !           855:      * Tricky point:  initialize the tag search just *after* the first
        !           856:      * character in the line, since the tagInfo structure already has all
        !           857:      * the tags for the first character.
        !           858:      */
        !           859: 
        !           860:     line = TkBTreeLineIndex(linePtr);
        !           861:     TkBTreeStartSearch(textPtr->tree, line, 1, TkBTreeNumLines(textPtr->tree),
        !           862:            0, (TkTextTag *) NULL, &tagInfo.search);
        !           863:     TkBTreeNextTag(&tagInfo.search);
        !           864:     prevPtr = NULL;
        !           865:     y = dInfoPtr->y;
        !           866:     maxY = dInfoPtr->maxY;
        !           867:     while ((linePtr != NULL) && (y < maxY)) {
        !           868:        register DLine *newPtr;
        !           869:        /*
        !           870:         * See if the next DLine matches the next line we want to
        !           871:         * appear on the screen.  If so then we can just use its
        !           872:         * information.  If not then create new DLine structures
        !           873:         * for the desired line and insert them into the list.
        !           874:         */
        !           875: 
        !           876:        if ((dlPtr == NULL) || (dlPtr->linePtr != linePtr)) {
        !           877:            newPtr = LayoutLine(textPtr, line, linePtr, &tagInfo);
        !           878:            if (prevPtr == NULL) {
        !           879:                dInfoPtr->dLinePtr = newPtr;
        !           880:            } else {
        !           881:                prevPtr->nextPtr = newPtr;
        !           882:            }
        !           883:            for (dlPtr2 = newPtr; dlPtr2->nextPtr != NULL;
        !           884:                    dlPtr2 = dlPtr2->nextPtr) {
        !           885:                /* Empty loop body. */
        !           886:            }
        !           887:            dlPtr2->nextPtr = dlPtr;
        !           888:            dlPtr = newPtr;
        !           889:        }
        !           890: 
        !           891:        /*
        !           892:         * Skip to the next line, and update the y-position while
        !           893:         * skipping.
        !           894:         */
        !           895: 
        !           896:        do {
        !           897:            dlPtr->y = y;
        !           898:            y += dlPtr->height;
        !           899:            prevPtr = dlPtr;
        !           900:            dlPtr = dlPtr->nextPtr;
        !           901:        } while ((dlPtr != NULL) && (dlPtr->linePtr == linePtr));
        !           902:        linePtr = TkBTreeNextLine(linePtr);
        !           903:        line++;
        !           904:     }
        !           905: 
        !           906:     /*
        !           907:      * Delete any DLine structures that don't fit on the screen and free
        !           908:      * up the tag array.
        !           909:      */
        !           910: 
        !           911:     FreeDLines(textPtr, dlPtr, (DLine *) NULL, 1);
        !           912:     if (tagInfo.tagPtrs != NULL) {
        !           913:        ckfree((char *) tagInfo.tagPtrs);
        !           914:     }
        !           915: 
        !           916:     /*
        !           917:      * Update the vertical scrollbar, if there is one.
        !           918:      */
        !           919: 
        !           920:     if (textPtr->yScrollCmd != NULL) {
        !           921:        int numLines, first, result, maxY, height;
        !           922:        char string[60];
        !           923: 
        !           924:        /*
        !           925:         * Count the number of text lines on the screen.
        !           926:         */
        !           927: 
        !           928:        maxY = 0;
        !           929:        for (numLines = 0, linePtr = NULL, dlPtr = dInfoPtr->dLinePtr;
        !           930:                dlPtr != NULL; dlPtr = dlPtr->nextPtr) {
        !           931:            if (dlPtr->linePtr != linePtr) {
        !           932:                numLines++;
        !           933:                linePtr = dlPtr->linePtr;
        !           934:            }
        !           935:            maxY = dlPtr->y + dlPtr->height;
        !           936:        }
        !           937: 
        !           938:        /*
        !           939:         * If the screen isn't completely full, then estimate the number of
        !           940:         * lines that would fit on it if it were full.
        !           941:         */
        !           942: 
        !           943:        height = dInfoPtr->maxY - dInfoPtr->y;
        !           944:        if (numLines == 0) {
        !           945:            numLines = height /
        !           946:                    (textPtr->fontPtr->ascent + textPtr->fontPtr->descent);
        !           947:        } else if (maxY < height) {
        !           948:            numLines = (numLines * height)/maxY;
        !           949:        }
        !           950:         /* DEH: be reasonable if dLinePtr is null */
        !           951:        if (dInfoPtr->dLinePtr == NULL) {
        !           952:          sprintf(string, " 0 0 0 0");
        !           953:        } else {
        !           954:          first = TkBTreeLineIndex(dInfoPtr->dLinePtr->linePtr);
        !           955:          sprintf(string, " %d %d %d %d", TkBTreeNumLines(textPtr->tree),
        !           956:                  numLines, first, first+numLines-1);
        !           957:        }
        !           958:        result = Tcl_VarEval(textPtr->interp, textPtr->yScrollCmd, string,
        !           959:                (char *) NULL);
        !           960:        if (result != TCL_OK) {
        !           961:            TkBindError(textPtr->interp);
        !           962:        }
        !           963:     }
        !           964: }
        !           965: 
        !           966: /*
        !           967:  *----------------------------------------------------------------------
        !           968:  *
        !           969:  * FreeDLines --
        !           970:  *
        !           971:  *     This procedure is called to free up all of the resources
        !           972:  *     associated with one or more DLine structures.
        !           973:  *
        !           974:  * Results:
        !           975:  *     None.
        !           976:  *
        !           977:  * Side effects:
        !           978:  *     Memory gets freed and various other resources are released.
        !           979:  *
        !           980:  *----------------------------------------------------------------------
        !           981:  */
        !           982: 
        !           983: static void
        !           984: FreeDLines(textPtr, firstPtr, lastPtr, unlink)
        !           985:     TkText *textPtr;                   /* Information about overall text
        !           986:                                         * widget. */
        !           987:     register DLine *firstPtr;          /* Pointer to first DLine to free up. */
        !           988:     DLine *lastPtr;                    /* Pointer to DLine just after last
        !           989:                                         * one to free (NULL means everything
        !           990:                                         * starting with firstPtr). */
        !           991:     int unlink;                                /* 1 means DLines are currently linked
        !           992:                                         * into the list rooted at
        !           993:                                         * textPtr->dInfoPtr->dLinePtr and
        !           994:                                         * they have to be unlinked.  0 means
        !           995:                                         * just free without unlinking. */
        !           996: {
        !           997:     register Chunk *chunkPtr, *nextChunkPtr;
        !           998:     register DLine *nextDLinePtr;
        !           999: 
        !          1000:     if (unlink) {
        !          1001:        if (textPtr->dInfoPtr->dLinePtr == firstPtr) {
        !          1002:            textPtr->dInfoPtr->dLinePtr = lastPtr;
        !          1003:        } else {
        !          1004:            register DLine *prevPtr;
        !          1005:            for (prevPtr = textPtr->dInfoPtr->dLinePtr;
        !          1006:                    prevPtr->nextPtr != firstPtr; prevPtr = prevPtr->nextPtr) {
        !          1007:                /* Empty loop body. */
        !          1008:            }
        !          1009:            prevPtr->nextPtr = lastPtr;
        !          1010:        }
        !          1011:     }
        !          1012:     while (firstPtr != lastPtr) {
        !          1013:        nextDLinePtr = firstPtr->nextPtr;
        !          1014:        for (chunkPtr = firstPtr->chunkPtr; chunkPtr != NULL;
        !          1015:                chunkPtr = nextChunkPtr) {
        !          1016:            FreeStyle(chunkPtr->stylePtr);
        !          1017:            nextChunkPtr = chunkPtr->nextPtr;
        !          1018:            ckfree((char *) chunkPtr);
        !          1019:        }
        !          1020:        ckfree((char *) firstPtr);
        !          1021:        firstPtr = nextDLinePtr;
        !          1022:     }
        !          1023: }
        !          1024: 
        !          1025: /*
        !          1026:  *----------------------------------------------------------------------
        !          1027:  *
        !          1028:  * DisplayDLine --
        !          1029:  *
        !          1030:  *     This procedure is invoked to draw a single line on the
        !          1031:  *     screen.
        !          1032:  *
        !          1033:  * Results:
        !          1034:  *     None.
        !          1035:  *
        !          1036:  * Side effects:
        !          1037:  *     The line given by dlPtr is drawn at its correct position in
        !          1038:  *     textPtr's window.  Note that this is one *display* line, not
        !          1039:  *     one *text* line.
        !          1040:  *
        !          1041:  *----------------------------------------------------------------------
        !          1042:  */
        !          1043: 
        !          1044: static void
        !          1045: DisplayDLine(textPtr, dlPtr, pixmap)
        !          1046:     TkText *textPtr;           /* Text widget in which to draw line. */
        !          1047:     register DLine *dlPtr;     /* Information about line to draw. */
        !          1048:     Pixmap pixmap;             /* Pixmap to use for double-buffering.
        !          1049:                                 * Caller must make sure it's large enough
        !          1050:                                 * to hold line. */
        !          1051: {
        !          1052:     register Style *stylePtr;
        !          1053:     register StyleValues *sValuePtr;
        !          1054:     register Chunk *chunkPtr;
        !          1055:     DInfo *dInfoPtr = textPtr->dInfoPtr;
        !          1056:     Display *display;
        !          1057:     int width, height, count, x;
        !          1058:     XFontStruct *fontPtr;
        !          1059: 
        !          1060:     /*
        !          1061:      * First, clear the area of the line to the background color for the
        !          1062:      * text widget.
        !          1063:      */
        !          1064: 
        !          1065:     display = Tk_Display(textPtr->tkwin);
        !          1066:     Tk_Fill3DRectangle(display, pixmap, textPtr->border, 0, 0,
        !          1067:            Tk_Width(textPtr->tkwin), dlPtr->height, 0, TK_RELIEF_FLAT);
        !          1068: 
        !          1069:     /*
        !          1070:      * Next, cycle through all of the chunks in the line displaying
        !          1071:      * backgrounds.  We need to do two passes, one for the backgrounds
        !          1072:      * and one for the characters, because some characters (e.g. italics
        !          1073:      * with heavy slants) may cross background boundaries.  If some
        !          1074:      * backgrounds are drawn after some text, the later backgrounds may
        !          1075:      * obliterate parts of earlier characters.
        !          1076:      */
        !          1077: 
        !          1078:     for (chunkPtr = dlPtr->chunkPtr; chunkPtr != NULL;
        !          1079:            chunkPtr = chunkPtr->nextPtr) {
        !          1080: 
        !          1081:        /*
        !          1082:         * Draw a special background for this chunk if one is specified
        !          1083:         * in its style.  Two tricks here:
        !          1084:         * 1. if this is the last chunk in the line then extend the
        !          1085:         *    background across to the end of the line.
        !          1086:         * 2. if the background is stippled, then we have to draw the
        !          1087:         *    stippled part specially, since Tk_Fill3DRectangle doesn't
        !          1088:         *    do stipples.
        !          1089:         */
        !          1090: 
        !          1091:        stylePtr = chunkPtr->stylePtr;
        !          1092:        sValuePtr = stylePtr->sValuePtr;
        !          1093:        if (sValuePtr->border != NULL) {
        !          1094:            if (chunkPtr->nextPtr != NULL) {
        !          1095:                width = chunkPtr->nextPtr->x - chunkPtr->x;
        !          1096:            } else {
        !          1097:                width = Tk_Width(textPtr->tkwin) - chunkPtr->x;
        !          1098:            }
        !          1099:            if (stylePtr->bgGC != NULL) {
        !          1100:                XFillRectangle(display, pixmap, stylePtr->bgGC, chunkPtr->x,
        !          1101:                        0, (unsigned int) width, (unsigned int) dlPtr->height);
        !          1102:                Tk_Draw3DRectangle(display, pixmap, sValuePtr->border,
        !          1103:                        chunkPtr->x, 0, width, dlPtr->height,
        !          1104:                        sValuePtr->borderWidth, sValuePtr->relief);
        !          1105:            } else {
        !          1106:                Tk_Fill3DRectangle(display, pixmap, sValuePtr->border,
        !          1107:                        chunkPtr->x, 0, width, dlPtr->height,
        !          1108:                        sValuePtr->borderWidth, sValuePtr->relief);
        !          1109:            }
        !          1110:        }
        !          1111:     }
        !          1112: 
        !          1113:     /*
        !          1114:      * If the insertion cursor is displayed on this line, then draw it
        !          1115:      * now, on top of the background but before the text.  As a special
        !          1116:      * workaround to keep the cursor visible on mono displays, write the default
        !          1117:      * background in the cursor area (instead of nothing) when the cursor
        !          1118:      * isn't on.  Otherwise the selection would hide the cursor.
        !          1119:      */
        !          1120: 
        !          1121:     if ((textPtr->insertAnnotPtr->linePtr == dlPtr->linePtr)
        !          1122:            && (textPtr->state == tkTextNormalUid)
        !          1123:            && (textPtr->flags & GOT_FOCUS)) {
        !          1124:        for (chunkPtr = dlPtr->chunkPtr; chunkPtr != NULL;
        !          1125:                chunkPtr = chunkPtr->nextPtr) {
        !          1126:            count = textPtr->insertAnnotPtr->ch
        !          1127:                    - (chunkPtr->text - dlPtr->linePtr->bytes);
        !          1128:            if (count < 0) {
        !          1129:                break;
        !          1130:            }
        !          1131:            if (count > chunkPtr->numChars) {
        !          1132:                continue;
        !          1133:            }
        !          1134: 
        !          1135:            /*
        !          1136:             * Deciding whether to display the cursor just after the last
        !          1137:             * character in a line is tricky because of various wrap
        !          1138:             * modes.  Do it unless we're in character wrap mode and
        !          1139:             * this line wraps, in which case it's better to display the
        !          1140:             * cursor on the next line.  For word wrap, there's an
        !          1141:             * undisplayed space character that the user must be able to
        !          1142:             * position the cursor in front of.  For no wrap, there's no
        !          1143:             * next line on which to display the cursor.
        !          1144:             */
        !          1145:            if ((count == chunkPtr->numChars)
        !          1146:                    && (textPtr->wrapMode == tkTextCharUid)
        !          1147:                    && (chunkPtr->text[count] != '\n')) {
        !          1148:                continue;
        !          1149:            }
        !          1150:            fontPtr = chunkPtr->stylePtr->sValuePtr->fontPtr;
        !          1151:            TkMeasureChars(fontPtr, chunkPtr->text, count, chunkPtr->x,
        !          1152:                    (int) 1000000, 0, &x);
        !          1153:            if (textPtr->flags & INSERT_ON) {
        !          1154:                Tk_Fill3DRectangle(display, pixmap, textPtr->insertBorder,
        !          1155:                        x - textPtr->insertWidth/2,
        !          1156:                        dlPtr->baseline - fontPtr->ascent,
        !          1157:                        textPtr->insertWidth,
        !          1158:                        fontPtr->ascent + fontPtr->descent,
        !          1159:                        textPtr->insertBorderWidth, TK_RELIEF_RAISED);
        !          1160:            } else if (Tk_DefaultDepth(Tk_Screen(textPtr->tkwin)) == 1) {
        !          1161:                Tk_Fill3DRectangle(display, pixmap, textPtr->border,
        !          1162:                        x - textPtr->insertWidth/2,
        !          1163:                        dlPtr->baseline - fontPtr->ascent,
        !          1164:                        textPtr->insertWidth,
        !          1165:                        fontPtr->ascent + fontPtr->descent,
        !          1166:                        0, TK_RELIEF_FLAT);
        !          1167:            }
        !          1168: 
        !          1169:        }
        !          1170:     }
        !          1171: 
        !          1172:     /*
        !          1173:      * Make another pass through all of the chunks to redraw all of
        !          1174:      * the text (and underlines, etc., if they're wanted).
        !          1175:      */
        !          1176: 
        !          1177:     for (chunkPtr = dlPtr->chunkPtr; chunkPtr != NULL;
        !          1178:            chunkPtr = chunkPtr->nextPtr) {
        !          1179:        stylePtr = chunkPtr->stylePtr;
        !          1180:        sValuePtr = stylePtr->sValuePtr;
        !          1181:        if (chunkPtr->numChars > 0) {
        !          1182:            TkDisplayChars(display, pixmap, stylePtr->fgGC, sValuePtr->fontPtr,
        !          1183:                    chunkPtr->text, chunkPtr->numChars, chunkPtr->x,
        !          1184:                    dlPtr->baseline, 0);
        !          1185:            if (sValuePtr->underline) {
        !          1186:                TkUnderlineChars(display, pixmap, stylePtr->fgGC,
        !          1187:                        sValuePtr->fontPtr, chunkPtr->text, chunkPtr->x,
        !          1188:                        dlPtr->baseline, 0, 0, chunkPtr->numChars-1);
        !          1189:            }
        !          1190:        }
        !          1191:     }
        !          1192: 
        !          1193:     /*
        !          1194:      * Copy the pixmap onto the screen.  If this is the last line on
        !          1195:      * the screen, only copy a piece of the line, so that it doesn't
        !          1196:      * overflow into the border area.  Another special trick:  copy the
        !          1197:      * padding area to the left of the line;  this is because the
        !          1198:      * insertion cursor sometimes overflows onto that area and we want
        !          1199:      * to get as much of the cursor as possible.
        !          1200:      */
        !          1201: 
        !          1202:     height = dlPtr->height;
        !          1203:     if ((height + dlPtr->y) > dInfoPtr->maxY) {
        !          1204:        height = dInfoPtr->maxY - dlPtr->y;
        !          1205:     }
        !          1206:     XCopyArea(display, pixmap, Tk_WindowId(textPtr->tkwin),
        !          1207:            dInfoPtr->copyGC, dInfoPtr->x - textPtr->padX, 0,
        !          1208:            dInfoPtr->maxX - (dInfoPtr->x - textPtr->padX),
        !          1209:            height, dInfoPtr->x - textPtr->padX, dlPtr->y);
        !          1210:     linesRedrawn++;
        !          1211: }
        !          1212: 
        !          1213: /*
        !          1214:  *----------------------------------------------------------------------
        !          1215:  *
        !          1216:  * DisplayText --
        !          1217:  *
        !          1218:  *     This procedure is invoked as a when-idle handler to update the
        !          1219:  *     display.  It only redisplays the parts of the text widget that
        !          1220:  *     are out of date.
        !          1221:  *
        !          1222:  * Results:
        !          1223:  *     None.
        !          1224:  *
        !          1225:  * Side effects:
        !          1226:  *     Information is redrawn on the screen.
        !          1227:  *
        !          1228:  *----------------------------------------------------------------------
        !          1229:  */
        !          1230: 
        !          1231: static void
        !          1232: DisplayText(clientData)
        !          1233:     ClientData clientData;     /* Information about widget. */
        !          1234: {
        !          1235:     register TkText *textPtr = (TkText *) clientData;
        !          1236:     DInfo *dInfoPtr = textPtr->dInfoPtr;
        !          1237:     Tk_Window tkwin;
        !          1238:     register DLine *dlPtr;
        !          1239:     Pixmap pixmap;
        !          1240:     int maxHeight;
        !          1241:     int bottomY = 0;           /* Initialization needed only to stop
        !          1242:                                 * compiler warnings. */
        !          1243: 
        !          1244:     assert(textPtr->updateTimerToken != NULL);
        !          1245:     
        !          1246:     textPtr->updateTimerToken = 0;
        !          1247: 
        !          1248:     if ((textPtr->tkwin == NULL) || !Tk_IsMapped(textPtr->tkwin)
        !          1249:            || (dInfoPtr->maxX <= dInfoPtr->x)
        !          1250:            || (dInfoPtr->maxY <= dInfoPtr->y)) {
        !          1251:        goto done;
        !          1252:     }
        !          1253:     numRedisplays++;
        !          1254: 
        !          1255:     /*
        !          1256:      * Choose a new current item if that is needed (this could cause
        !          1257:      * event handlers to be invoked, hence the preserve/release calls
        !          1258:      * and the loop, since the handlers could conceivably necessitate
        !          1259:      * yet another current item calculation).  The tkwin check is because
        !          1260:      * the whole window could go away in the Tk_Release call.
        !          1261:      */
        !          1262: 
        !          1263:     while (dInfoPtr->flags & REPICK_NEEDED) {
        !          1264:        Tk_Preserve((ClientData) textPtr);
        !          1265:        dInfoPtr->flags &= ~REPICK_NEEDED;
        !          1266:        TkTextPickCurrent(textPtr, &textPtr->pickEvent);
        !          1267:        tkwin = textPtr->tkwin;
        !          1268:        Tk_Release((ClientData) textPtr);
        !          1269:        if (tkwin == NULL) {
        !          1270:            return;
        !          1271:        }
        !          1272:     }
        !          1273: 
        !          1274:     /*
        !          1275:      * First recompute what's supposed to be displayed.
        !          1276:      */
        !          1277: 
        !          1278:     UpdateDisplayInfo(textPtr);
        !          1279: 
        !          1280:     /*
        !          1281:      * Redraw the borders if that's needed.
        !          1282:      */
        !          1283: 
        !          1284:     if (dInfoPtr->flags & REDRAW_BORDERS) {
        !          1285:        Tk_Draw3DRectangle(Tk_Display(textPtr->tkwin),
        !          1286:                Tk_WindowId(textPtr->tkwin), textPtr->border,
        !          1287:                0, 0, Tk_Width(textPtr->tkwin), Tk_Height(textPtr->tkwin),
        !          1288:                textPtr->borderWidth, textPtr->relief);
        !          1289:     }
        !          1290: 
        !          1291:     /*
        !          1292:      * See if it's possible to bring some parts of the screen up-to-date
        !          1293:      * by scrolling (copying from other parts of the screen).
        !          1294:      */
        !          1295: 
        !          1296:     for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL; dlPtr = dlPtr->nextPtr) {
        !          1297:        register DLine *dlPtr2;
        !          1298:        int offset, height;
        !          1299: 
        !          1300:        if ((dlPtr->oldY == -1) || (dlPtr->y == dlPtr->oldY)
        !          1301:                || ((dlPtr->oldY + dlPtr->height) > dInfoPtr->maxY)) {
        !          1302:            continue;
        !          1303:        }
        !          1304: 
        !          1305:        /*
        !          1306:         * This line is already drawn somewhere in the window so it only
        !          1307:         * needs to be copied to its new location.  See if there's a group
        !          1308:         * of lines that can all be copied together.
        !          1309:         */
        !          1310: 
        !          1311:        offset = dlPtr->y - dlPtr->oldY;
        !          1312:        height = dlPtr->height;
        !          1313:        for (dlPtr2 = dlPtr->nextPtr; dlPtr2 != NULL;
        !          1314:                dlPtr2 = dlPtr2->nextPtr) {
        !          1315:            if ((dlPtr2->oldY == -1)
        !          1316:                    || ((dlPtr2->oldY + offset) != dlPtr2->y)
        !          1317:                    || ((dlPtr2->oldY + dlPtr2->height) > dInfoPtr->maxY)) {
        !          1318:                break;
        !          1319:            }
        !          1320:            height += dlPtr2->height;
        !          1321:        }
        !          1322: 
        !          1323:        /*
        !          1324:         * Copy the information and update the lines to show that they've
        !          1325:         * been copied.  Reduce the height of the area being copied if
        !          1326:         * necessary to avoid overwriting the border area.
        !          1327:         */
        !          1328: 
        !          1329:        if ((dlPtr->y + height) > dInfoPtr->maxY) {
        !          1330:            height = dInfoPtr->maxY - dlPtr->y;
        !          1331:        }
        !          1332:        XCopyArea(Tk_Display(textPtr->tkwin), Tk_WindowId(textPtr->tkwin),
        !          1333:                Tk_WindowId(textPtr->tkwin), dInfoPtr->scrollGC,
        !          1334:                dInfoPtr->x - textPtr->padX, dlPtr->oldY,
        !          1335:                dInfoPtr->maxX - (dInfoPtr->x - textPtr->padX),
        !          1336:                height, dInfoPtr->x - textPtr->padX, dlPtr->y);
        !          1337:        numCopies++;
        !          1338:        while (1) {
        !          1339:            dlPtr->oldY = dlPtr->y;
        !          1340:            if (dlPtr->nextPtr == dlPtr2) {
        !          1341:                break;
        !          1342:            }
        !          1343:            dlPtr = dlPtr->nextPtr;
        !          1344:        }
        !          1345: 
        !          1346:        /*
        !          1347:         * It's possible that part of the area copied above was obscured.
        !          1348:         * To handle this situation, read expose-related events generated
        !          1349:         * during the XCopyArea operation.
        !          1350:         */
        !          1351: 
        !          1352:        while (1) {
        !          1353:            XEvent event;
        !          1354: 
        !          1355:            XWindowEvent(Tk_Display(textPtr->tkwin),
        !          1356:                    Tk_WindowId(textPtr->tkwin), ExposureMask, &event);
        !          1357:            if (event.type == NoExpose) {
        !          1358:                break;
        !          1359:            } else if (event.type == GraphicsExpose) {
        !          1360:                TkTextRedrawRegion(textPtr, event.xgraphicsexpose.x,
        !          1361:                        event.xgraphicsexpose.y, event.xgraphicsexpose.width,
        !          1362:                        event.xgraphicsexpose.height);
        !          1363:                if (event.xgraphicsexpose.count == 0) {
        !          1364:                    damagedCopies++;
        !          1365:                    break;
        !          1366:                }
        !          1367:            } else if (event.type == Expose) {
        !          1368:                /*
        !          1369:                 * A tricky situation.  This event must already have been
        !          1370:                 * queued up before the XCopyArea was issued.  If the area
        !          1371:                 * in this event overlaps the area copied, then some of the
        !          1372:                 * bits that were copied were bogus.  The easiest way to
        !          1373:                 * handle this is to issue two redisplays:  one for the
        !          1374:                 * original area and one for the area shifted as if it was
        !          1375:                 * in the copied area.
        !          1376:                 */
        !          1377: 
        !          1378:                TkTextRedrawRegion(textPtr, event.xexpose.x,
        !          1379:                        event.xexpose.y, event.xexpose.width,
        !          1380:                        event.xexpose.height);
        !          1381:                TkTextRedrawRegion(textPtr, event.xexpose.x,
        !          1382:                        event.xexpose.y + offset, event.xexpose.width,
        !          1383:                        event.xexpose.height);
        !          1384:            } else {
        !          1385:                panic("DisplayText received unknown exposure event");
        !          1386:            }
        !          1387:        }
        !          1388:     }
        !          1389: 
        !          1390:     /*
        !          1391:      * Now we have to redraw the lines that couldn't be updated by
        !          1392:      * scrolling.  First, compute the height of the largest line and
        !          1393:      * allocate an off-screen pixmap to use for double-buffered
        !          1394:      * displays.
        !          1395:      */
        !          1396: 
        !          1397:     maxHeight = -1;
        !          1398:     for (dlPtr = textPtr->dInfoPtr->dLinePtr; dlPtr != NULL;
        !          1399:            dlPtr = dlPtr->nextPtr) {
        !          1400:        if ((dlPtr->height > maxHeight) && (dlPtr->oldY != dlPtr->y)) {
        !          1401:            maxHeight = dlPtr->height;
        !          1402:        }
        !          1403:        bottomY = dlPtr->y + dlPtr->height;
        !          1404:     }
        !          1405:     if (maxHeight >= 0) {
        !          1406:        pixmap = XCreatePixmap(Tk_Display(textPtr->tkwin),
        !          1407:                Tk_WindowId(textPtr->tkwin), Tk_Width(textPtr->tkwin),
        !          1408:                maxHeight, Tk_DefaultDepth(Tk_Screen(textPtr->tkwin)));
        !          1409:        for (dlPtr = textPtr->dInfoPtr->dLinePtr; dlPtr != NULL;
        !          1410:                dlPtr = dlPtr->nextPtr) {
        !          1411:            if (dlPtr->oldY != dlPtr->y) {
        !          1412:                DisplayDLine(textPtr, dlPtr, pixmap);
        !          1413:                dlPtr->oldY = dlPtr->y;
        !          1414:            }
        !          1415:        }
        !          1416:        XFreePixmap(Tk_Display(textPtr->tkwin), pixmap);
        !          1417:     }
        !          1418: 
        !          1419:     /*
        !          1420:      * Lastly, see if we need to refresh the part of the window below
        !          1421:      * the last line of text (if there is any such area).
        !          1422:      */
        !          1423: 
        !          1424:     if (dInfoPtr->topOfEof > dInfoPtr->maxY) {
        !          1425:        dInfoPtr->topOfEof = dInfoPtr->maxY;
        !          1426:     }
        !          1427:     if (bottomY < dInfoPtr->topOfEof) {
        !          1428:        Tk_Fill3DRectangle(Tk_Display(textPtr->tkwin),
        !          1429:                Tk_WindowId(textPtr->tkwin), textPtr->border,
        !          1430:                dInfoPtr->x, bottomY, dInfoPtr->maxX - dInfoPtr->x,
        !          1431:                dInfoPtr->topOfEof-bottomY, 0, TK_RELIEF_FLAT);
        !          1432:     }
        !          1433:     dInfoPtr->topOfEof = bottomY;
        !          1434:     if (dInfoPtr->topOfEof > dInfoPtr->maxY) {
        !          1435:        dInfoPtr->topOfEof = dInfoPtr->maxY;
        !          1436:     }
        !          1437: 
        !          1438:     done:
        !          1439:     dInfoPtr->flags &= ~(REDRAW_PENDING|REDRAW_BORDERS);
        !          1440: }
        !          1441: 
        !          1442: /*
        !          1443:  *----------------------------------------------------------------------
        !          1444:  *
        !          1445:  * TkTextRedrawRegion --
        !          1446:  *
        !          1447:  *     This procedure is invoked to schedule a redisplay for a given
        !          1448:  *     region of a text widget.  The redisplay itself may not occur
        !          1449:  *     immediately:  it's scheduled as a when-idle handler.
        !          1450:  *
        !          1451:  * Results:
        !          1452:  *     None.
        !          1453:  *
        !          1454:  * Side effects:
        !          1455:  *     Information will eventually be redrawn on the screen.
        !          1456:  *
        !          1457:  *----------------------------------------------------------------------
        !          1458:  */
        !          1459: 
        !          1460:        /* ARGSUSED */
        !          1461: void
        !          1462: TkTextRedrawRegion(textPtr, x, y, width, height)
        !          1463:     TkText *textPtr;           /* Widget record for text widget. */
        !          1464:     int x, y;                  /* Coordinates of upper-left corner of area
        !          1465:                                 * to be redrawn, in pixels relative to
        !          1466:                                 * textPtr's window. */
        !          1467:     int width, height;         /* Width and height of area to be redrawn. */
        !          1468: {
        !          1469:     register DLine *dlPtr;
        !          1470:     DInfo *dInfoPtr = textPtr->dInfoPtr;
        !          1471:     int maxY;
        !          1472: 
        !          1473:     /*
        !          1474:      * Find all lines that overlap the given region and mark them for
        !          1475:      * redisplay.
        !          1476:      */
        !          1477: 
        !          1478:     maxY = y + height;
        !          1479:     for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL;
        !          1480:            dlPtr = dlPtr->nextPtr) {
        !          1481:        if (((dlPtr->y + dlPtr->height) > y) && (dlPtr->y < maxY)) {
        !          1482:            dlPtr->oldY = -1;
        !          1483:        }
        !          1484:     }
        !          1485:     if (dInfoPtr->topOfEof < maxY) {
        !          1486:        dInfoPtr->topOfEof = maxY;
        !          1487:     }
        !          1488: 
        !          1489:     /*
        !          1490:      * Schedule the redisplay operation if there isn't one already
        !          1491:      * scheduled.
        !          1492:      */
        !          1493: 
        !          1494:     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
        !          1495:        dInfoPtr->flags |= REDRAW_PENDING;
        !          1496: //     Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
        !          1497:        assert(textPtr->updateTimerToken == NULL);
        !          1498:        if (textPtr->updateTimerToken == NULL) {
        !          1499:            textPtr->updateTimerToken =
        !          1500:              Tk_CreateTimerHandler(
        !          1501:                TextUpdateTime,
        !          1502:                DisplayText,
        !          1503:                (ClientData) textPtr);
        !          1504:        }
        !          1505:     }
        !          1506:     if ((x < dInfoPtr->x) || (y < dInfoPtr->y)
        !          1507:            || ((x + width) > dInfoPtr->maxX) || (maxY > dInfoPtr->maxY)) {
        !          1508:        dInfoPtr->flags |= REDRAW_BORDERS;
        !          1509:     }
        !          1510: }
        !          1511: 
        !          1512: /*
        !          1513:  *----------------------------------------------------------------------
        !          1514:  *
        !          1515:  * TkTextLinesChanged --
        !          1516:  *
        !          1517:  *     This procedure is invoked when lines in a text widget are about
        !          1518:  *     to be modified in a way that changes how they are displayed (e.g.
        !          1519:  *     characters were inserted, the line was deleted, or tag information
        !          1520:  *     was changed).  This procedure must be called *before* a change is
        !          1521:  *     made, so that pointers to TkTextLines in the display information
        !          1522:  *     are still valid.
        !          1523:  *
        !          1524:  * Results:
        !          1525:  *     None.
        !          1526:  *
        !          1527:  * Side effects:
        !          1528:  *     The indicated lines will be redisplayed at some point in the
        !          1529:  *     future (the actual redisplay is scheduled as a when-idle handler).
        !          1530:  *
        !          1531:  *----------------------------------------------------------------------
        !          1532:  */
        !          1533: 
        !          1534: void
        !          1535: TkTextLinesChanged(textPtr, first, last)
        !          1536:     TkText *textPtr;           /* Widget record for text widget. */
        !          1537:     int first;                 /* Index of first line that must be
        !          1538:                                 * redisplayed. */
        !          1539:     int last;                  /* Index of last line to redisplay. */
        !          1540: {
        !          1541:     DInfo *dInfoPtr = textPtr->dInfoPtr;
        !          1542:     DLine *firstPtr, *lastPtr;
        !          1543: 
        !          1544:     /*
        !          1545:      * Find the DLines corresponding to first and last+1.
        !          1546:      */
        !          1547: 
        !          1548:     firstPtr = FindDLine(dInfoPtr->dLinePtr, first);
        !          1549:     if (firstPtr == NULL) {
        !          1550:        return;
        !          1551:     }
        !          1552:     lastPtr = FindDLine(dInfoPtr->dLinePtr, last+1);
        !          1553:     if (firstPtr == lastPtr) {
        !          1554:        return;
        !          1555:     }
        !          1556: 
        !          1557:     /*
        !          1558:      * Delete all the DLines from first up through last (but not including
        !          1559:      * lastPtr, which points to the first line *outside* the range).
        !          1560:      */
        !          1561: 
        !          1562:     FreeDLines(textPtr, firstPtr, lastPtr, 1);
        !          1563: 
        !          1564:     /*
        !          1565:      * Schedule both a redisplay and a recomputation of display information.
        !          1566:      */
        !          1567: 
        !          1568:     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
        !          1569: //     Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
        !          1570:         assert(textPtr->updateTimerToken == NULL);
        !          1571:        if (textPtr->updateTimerToken == NULL) {
        !          1572:            textPtr->updateTimerToken =
        !          1573:              Tk_CreateTimerHandler(
        !          1574:                TextUpdateTime,
        !          1575:                DisplayText,
        !          1576:                (ClientData) textPtr);
        !          1577:        }
        !          1578:     }
        !          1579:     dInfoPtr->flags |= REDRAW_PENDING | DINFO_OUT_OF_DATE | REPICK_NEEDED;
        !          1580: }
        !          1581: 
        !          1582: /*
        !          1583:  *----------------------------------------------------------------------
        !          1584:  *
        !          1585:  * TkTextRedrawTag --
        !          1586:  *
        !          1587:  *     This procedure is invoked to request a redraw of all characters
        !          1588:  *     in a given range of characters that have a particular tag on or
        !          1589:  *     off.  It's called, for example, when characters are tagged or
        !          1590:  *     untagged, or when tag options change.
        !          1591:  *
        !          1592:  * Results:
        !          1593:  *     None.
        !          1594:  *
        !          1595:  * Side effects:
        !          1596:  *     Information on the screen may be redrawn, and the layout of
        !          1597:  *     the screen may change.
        !          1598:  *
        !          1599:  *----------------------------------------------------------------------
        !          1600:  */
        !          1601: 
        !          1602: void
        !          1603: TkTextRedrawTag(textPtr, line1, ch1, line2, ch2, tagPtr, withTag)
        !          1604:     TkText *textPtr;           /* Widget record for text widget. */
        !          1605:     int line1, ch1;            /* Index of first character in range of
        !          1606:                                 * interest. */
        !          1607:     int line2, ch2;            /* Index of character just after last one
        !          1608:                                 * in range of interest. */
        !          1609:     TkTextTag *tagPtr;         /* Information about tag. */
        !          1610:     int withTag;               /* 1 means redraw characters that have the
        !          1611:                                 * tag, 0 means redraw those without. */
        !          1612: {
        !          1613:     register DLine *dlPtr;
        !          1614:     DLine *endPtr;
        !          1615:     int topLine, tagOn;
        !          1616:     TkTextSearch search;
        !          1617:     DInfo *dInfoPtr = textPtr->dInfoPtr;
        !          1618: 
        !          1619:     /*
        !          1620:      * Round up the starting position if it's before the first line
        !          1621:      * visible on the screen (we only care about what's on the screen).
        !          1622:      */
        !          1623: 
        !          1624:     dlPtr = dInfoPtr->dLinePtr;
        !          1625:     if (dlPtr == NULL) {
        !          1626:        return;
        !          1627:     }
        !          1628:     topLine = TkBTreeLineIndex(dlPtr->linePtr);
        !          1629:     if (topLine > line1) {
        !          1630:        line1 = topLine;
        !          1631:        ch1 = 0;
        !          1632:     }
        !          1633: 
        !          1634:     /* 
        !          1635:      * Initialize a search through all transitions on the tag, starting
        !          1636:      * with the first transition where the tag's current state is different
        !          1637:      * from what it will eventually be.
        !          1638:      */
        !          1639: 
        !          1640:     TkBTreeStartSearch(textPtr->tree, line1, ch1+1, line2, ch2,
        !          1641:            tagPtr, &search);
        !          1642:     tagOn = TkBTreeCharTagged(search.linePtr, ch1, tagPtr);
        !          1643:     if (tagOn != withTag) {
        !          1644:        if (!TkBTreeNextTag(&search)) {
        !          1645:            return;
        !          1646:        }
        !          1647:     }
        !          1648: 
        !          1649:     /*
        !          1650:      * Each loop through the loop below is for one range of characters
        !          1651:      * where the tag's current state is different than its eventual
        !          1652:      * state.  At the top of the loop, search contains information about
        !          1653:      * the first character in the range.
        !          1654:      */
        !          1655: 
        !          1656:     while (1) {
        !          1657:        /*
        !          1658:         * Find the first DLine structure in the range.
        !          1659:         */
        !          1660: 
        !          1661:        dlPtr = FindDLine(dlPtr, search.line1);
        !          1662:        if (dlPtr == NULL) {
        !          1663:            break;
        !          1664:        }
        !          1665: 
        !          1666:        /*
        !          1667:         * Find the first DLine structure that's past the end of the range.
        !          1668:         */
        !          1669: 
        !          1670:        if (TkBTreeNextTag(&search)) {
        !          1671:            endPtr = FindDLine(dlPtr,
        !          1672:                    (search.ch1 > 0) ? (search.line1 + 1) : search.line1);
        !          1673:        } else {
        !          1674:            endPtr = FindDLine(dlPtr,
        !          1675:                    (ch2 > 0) ? (search.line2 + 1) : search.line2);
        !          1676:        }
        !          1677: 
        !          1678:        /*
        !          1679:         * Delete all of the display lines in the range, so that they'll
        !          1680:         * be re-layed out and redrawn.
        !          1681:         */
        !          1682: 
        !          1683:        FreeDLines(textPtr, dlPtr, endPtr, 1);
        !          1684:        dlPtr = endPtr;
        !          1685: 
        !          1686:        /*
        !          1687:         * Find the first text line in the next range.
        !          1688:         */
        !          1689: 
        !          1690:        if (!TkBTreeNextTag(&search)) {
        !          1691:            break;
        !          1692:        }
        !          1693:     }
        !          1694: 
        !          1695:     /*
        !          1696:      * Lastly, schedule a redisplay and layout recalculation if they
        !          1697:      * aren't already pending.
        !          1698:      */
        !          1699: 
        !          1700:     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
        !          1701: //     Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
        !          1702:         assert(textPtr->updateTimerToken == NULL);
        !          1703:         if (textPtr->updateTimerToken == NULL) {
        !          1704:            textPtr->updateTimerToken =
        !          1705:              Tk_CreateTimerHandler(
        !          1706:                TextUpdateTime,
        !          1707:                DisplayText,
        !          1708:                (ClientData) textPtr);
        !          1709:        }
        !          1710:     }
        !          1711:     dInfoPtr->flags |= REDRAW_PENDING | DINFO_OUT_OF_DATE | REPICK_NEEDED;
        !          1712: }
        !          1713: 
        !          1714: /*
        !          1715:  *----------------------------------------------------------------------
        !          1716:  *
        !          1717:  * TkTextRelayoutWindow --
        !          1718:  *
        !          1719:  *     This procedure is called when something has happened that
        !          1720:  *     invalidates the whole layout of characters on the screen, such
        !          1721:  *     as a change in a configuration option for the overall text
        !          1722:  *     widget or a change in the window size.  It causes all display
        !          1723:  *     information to be recomputed and the window to be redrawn.
        !          1724:  *
        !          1725:  * Results:
        !          1726:  *     None.
        !          1727:  *
        !          1728:  * Side effects:
        !          1729:  *     All the display information will be recomputed for the window
        !          1730:  *     and the window will be redrawn.
        !          1731:  *
        !          1732:  *----------------------------------------------------------------------
        !          1733:  */
        !          1734: 
        !          1735: void
        !          1736: TkTextRelayoutWindow(textPtr)
        !          1737:     TkText *textPtr;           /* Widget record for text widget. */
        !          1738: {
        !          1739:     DInfo *dInfoPtr = textPtr->dInfoPtr;
        !          1740: 
        !          1741:     /*
        !          1742:      * Throw away all the current layout information.
        !          1743:      */
        !          1744: 
        !          1745:     FreeDLines(textPtr, dInfoPtr->dLinePtr, (DLine *) NULL, 1);
        !          1746:     dInfoPtr->dLinePtr = NULL;
        !          1747: 
        !          1748:     /*
        !          1749:      * Recompute some overall things for the layout.
        !          1750:      */
        !          1751: 
        !          1752:     dInfoPtr->x = textPtr->borderWidth + textPtr->padX;
        !          1753:     dInfoPtr->y = textPtr->borderWidth + textPtr->padY;
        !          1754:     dInfoPtr->maxX = Tk_Width(textPtr->tkwin) - dInfoPtr->x;
        !          1755:     dInfoPtr->maxY = Tk_Height(textPtr->tkwin) - dInfoPtr->y;
        !          1756:     dInfoPtr->topOfEof = dInfoPtr->maxY;
        !          1757: 
        !          1758:     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
        !          1759: //     Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
        !          1760:         assert(textPtr->updateTimerToken == NULL);
        !          1761:        if (textPtr->updateTimerToken == NULL) {
        !          1762:            textPtr->updateTimerToken =
        !          1763:              Tk_CreateTimerHandler(
        !          1764:                TextUpdateTime,
        !          1765:                DisplayText,
        !          1766:                (ClientData) textPtr);
        !          1767:        }
        !          1768:     }
        !          1769:     dInfoPtr->flags |= REDRAW_PENDING | REDRAW_BORDERS | DINFO_OUT_OF_DATE | REPICK_NEEDED;
        !          1770: }
        !          1771: 
        !          1772: /*
        !          1773:  *----------------------------------------------------------------------
        !          1774:  *
        !          1775:  * TkTextSetView --
        !          1776:  *
        !          1777:  *     This procedure is called to specify what lines are to be
        !          1778:  *     displayed in a text widget.
        !          1779:  *
        !          1780:  * Results:
        !          1781:  *     None.
        !          1782:  *
        !          1783:  * Side effects:
        !          1784:  *     The display will (eventually) be updated so that the line
        !          1785:  *     given by "line" is visible on the screen at the position
        !          1786:  *     determined by "pickPlace".
        !          1787:  *
        !          1788:  *----------------------------------------------------------------------
        !          1789:  */
        !          1790: 
        !          1791: void
        !          1792: TkTextSetView(textPtr, line, pickPlace)
        !          1793:     TkText *textPtr;           /* Widget record for text widget. */
        !          1794:     int line;                  /* Number of line that is to appear somewhere
        !          1795:                                 * in the window.  This line number must
        !          1796:                                 * be a valid one in the file. */
        !          1797:     int pickPlace;             /* 0 means topLine must appear at top of
        !          1798:                                 * screen.  1 means we get to pick where it
        !          1799:                                 * appears:  minimize screen motion or else
        !          1800:                                 * display line at center of screen. */
        !          1801: {
        !          1802:     DInfo *dInfoPtr = textPtr->dInfoPtr;
        !          1803:     register DLine *dlPtr, *dlPtr2;
        !          1804:     TkTextLine *linePtr;
        !          1805:     int curTopLine, curBotLine;
        !          1806:     int bottomY;
        !          1807:     TagInfo tagInfo;
        !          1808: #define CLOSE_LINES 5
        !          1809: 
        !          1810:     if (!pickPlace) {
        !          1811:        /*
        !          1812:         * The line must go at the top of the screen.  See if the new
        !          1813:         * topmost line is already somewhere on the screen.  If so then
        !          1814:         * delete all the DLine structures ahead of it.  Otherwise just
        !          1815:         * leave all the DLine's alone (if the new topmost line is above
        !          1816:         * the top of the current window, i.e. we're scrolling back towards
        !          1817:         * the beginning of the file we may be able to reuse some of the
        !          1818:         * information that's currently on the screen without redisplaying
        !          1819:         * it all.
        !          1820:         */
        !          1821:     
        !          1822:        dlPtr = FindDLine(dInfoPtr->dLinePtr, line);
        !          1823:        if ((dlPtr != NULL) && (dlPtr != dInfoPtr->dLinePtr)) {
        !          1824:            FreeDLines(textPtr, dInfoPtr->dLinePtr, dlPtr, 1);
        !          1825:        }
        !          1826:     
        !          1827:        textPtr->topLinePtr = TkBTreeFindLine(textPtr->tree, line);
        !          1828:        goto scheduleUpdate;
        !          1829:     }
        !          1830: 
        !          1831:     /*
        !          1832:      * We have to pick where to display the given line.  First, bring
        !          1833:      * the display information up to date and see if the line will be
        !          1834:      * completely visible in the current screen configuration.  If so
        !          1835:      * then there's nothing to do.
        !          1836:      */
        !          1837: 
        !          1838:     if (dInfoPtr->flags & DINFO_OUT_OF_DATE) {
        !          1839:        UpdateDisplayInfo(textPtr);
        !          1840:     }
        !          1841:     linePtr = TkBTreeFindLine(textPtr->tree, line);
        !          1842:     /* DEH: return if dlPtr is null */
        !          1843:     if ((dlPtr = dInfoPtr->dLinePtr) == NULL)
        !          1844:         return;
        !          1845:     for (; ; dlPtr = dlPtr->nextPtr) {
        !          1846:        if (dlPtr->nextPtr == NULL) {
        !          1847:            break;
        !          1848:        }
        !          1849:        if ((dlPtr->linePtr == linePtr)
        !          1850:                && (dlPtr->nextPtr->linePtr != linePtr)) {
        !          1851:            break;
        !          1852:        }
        !          1853:     }
        !          1854:     if ((dlPtr->linePtr == linePtr)
        !          1855:            && ((dlPtr->y + dlPtr->height) <= dInfoPtr->maxY)) {
        !          1856:        return;
        !          1857:     }
        !          1858: 
        !          1859:     /*
        !          1860:      * The desired line isn't already on-screen.  See if it is within
        !          1861:      * a few lines of the top of the window.  If so then just make it
        !          1862:      * the top line on the screen.
        !          1863:      */
        !          1864: 
        !          1865:     bottomY = (dInfoPtr->y + dInfoPtr->maxY)/2;
        !          1866:     curTopLine = TkBTreeLineIndex(dInfoPtr->dLinePtr->linePtr);
        !          1867:     if (line < curTopLine) {
        !          1868:        if (line >= (curTopLine-CLOSE_LINES)) {
        !          1869:            textPtr->topLinePtr = TkBTreeFindLine(textPtr->tree, line);
        !          1870:            goto scheduleUpdate;
        !          1871:        }
        !          1872:     } else {
        !          1873:        /*
        !          1874:         * The desired line is below the bottom of the screen.  If it is
        !          1875:         * within a few lines of the bottom of the screen then position
        !          1876:         * it at the bottom of the screen. (At this point dlPtr points to
        !          1877:         * the last line on the screen)
        !          1878:         */
        !          1879:     
        !          1880:        curBotLine = TkBTreeLineIndex(dlPtr->linePtr);
        !          1881:        if (line <= (curBotLine+5)) {
        !          1882:            bottomY = dInfoPtr->maxY;
        !          1883:        }
        !          1884:     }
        !          1885: 
        !          1886:     /*
        !          1887:      * Our job now is arrange the display so that "line" appears as
        !          1888:      * low on the screen as possible but with its bottom no lower
        !          1889:      * than bottomY (bottomY is the bottom of the window if the
        !          1890:      * desired line is just below the current screen, otherwise it
        !          1891:      * is the center of the window.  Work upwards (through smaller
        !          1892:      * line numbers) computing how much space lines take, until we
        !          1893:      * fine the line that should be at the top of the screen.
        !          1894:      */
        !          1895: 
        !          1896:     for (textPtr->topLinePtr = linePtr = TkBTreeFindLine(textPtr->tree, line);
        !          1897:            ; line--, textPtr->topLinePtr = linePtr,
        !          1898:            linePtr = TkBTreeFindLine(textPtr->tree, line)) {
        !          1899:        tagInfo.tagPtrs = TkBTreeGetTags(textPtr->tree, linePtr, 0,
        !          1900:                &tagInfo.numTags);
        !          1901:        tagInfo.arraySize = tagInfo.numTags;
        !          1902:        TkBTreeStartSearch(textPtr->tree, line, 1, line+1, 0,
        !          1903:                (TkTextTag *) NULL, &tagInfo.search);
        !          1904:        TkBTreeNextTag(&tagInfo.search);
        !          1905:        dlPtr = LayoutLine(textPtr, line, linePtr, &tagInfo);
        !          1906:        for (dlPtr2 = dlPtr; dlPtr2 != NULL; dlPtr2 = dlPtr2->nextPtr) {
        !          1907:            bottomY -= dlPtr2->height;
        !          1908:        }
        !          1909:        FreeDLines(textPtr, dlPtr, (DLine *) NULL, 0);
        !          1910:        if (tagInfo.tagPtrs != NULL) {
        !          1911:            ckfree((char *) tagInfo.tagPtrs);
        !          1912:        }
        !          1913:        if ((bottomY <= 0) || (line <= 0)) {
        !          1914:            break;
        !          1915:        }
        !          1916:     }
        !          1917: 
        !          1918:     scheduleUpdate:
        !          1919:     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
        !          1920: //     Tk_DoWhenIdle(DisplayText, (ClientData) textPtr);
        !          1921:         assert(textPtr->updateTimerToken == NULL);
        !          1922:        if (textPtr->updateTimerToken == NULL) {
        !          1923:            textPtr->updateTimerToken =
        !          1924:              Tk_CreateTimerHandler(
        !          1925:                TextUpdateTime,
        !          1926:                DisplayText,
        !          1927:                (ClientData) textPtr);
        !          1928:        }
        !          1929:     }
        !          1930:     dInfoPtr->flags |= REDRAW_PENDING | DINFO_OUT_OF_DATE | REPICK_NEEDED;
        !          1931: }
        !          1932: 
        !          1933: /*
        !          1934:  *----------------------------------------------------------------------
        !          1935:  *
        !          1936:  * FindDLine --
        !          1937:  *
        !          1938:  *     This procedure is called to find the DLine corresponding to a
        !          1939:  *     given text line.
        !          1940:  *
        !          1941:  * Results:
        !          1942:  *     The return value is a pointer to the first DLine found in the
        !          1943:  *     list headed by dlPtr whose line number is greater or equal to
        !          1944:  *     line.  If there is no such line in the list then NULL is returned.
        !          1945:  *
        !          1946:  * Side effects:
        !          1947:  *     None.
        !          1948:  *
        !          1949:  *----------------------------------------------------------------------
        !          1950:  */
        !          1951: 
        !          1952: static DLine *
        !          1953: FindDLine(dlPtr, line)
        !          1954:     register DLine *dlPtr;     /* Pointer to first in list of DLines
        !          1955:                                 * to search. */
        !          1956:     int line;                  /* Line number in text that is desired. */
        !          1957: {
        !          1958:     TkTextLine *linePtr;
        !          1959:     int thisLine;
        !          1960: 
        !          1961:     if (dlPtr == NULL) {
        !          1962:        return NULL;
        !          1963:     }
        !          1964:     thisLine = TkBTreeLineIndex(dlPtr->linePtr);
        !          1965:     while (thisLine < line) {
        !          1966:        /*
        !          1967:         * This DLine isn't the right one.  Go on to the next DLine
        !          1968:         * (skipping multiple DLine's for the same text line).
        !          1969:         */
        !          1970: 
        !          1971:        linePtr = dlPtr->linePtr;
        !          1972:        do {
        !          1973:            dlPtr = dlPtr->nextPtr;
        !          1974:            if (dlPtr == NULL) {
        !          1975:                return NULL;
        !          1976:            }
        !          1977:        } while (dlPtr->linePtr == linePtr);
        !          1978: 
        !          1979:        /*
        !          1980:         * Step through text lines, keeping track of the line number
        !          1981:         * we're on, until we catch up to dlPtr (remember, there could
        !          1982:         * be gaps in the DLine list where DLine's have been deleted).
        !          1983:         */
        !          1984: 
        !          1985:        do {
        !          1986:            linePtr = TkBTreeNextLine(linePtr);
        !          1987:            thisLine++;
        !          1988:            if (linePtr == NULL) {
        !          1989:                panic("FindDLine reached end of text");
        !          1990:            }
        !          1991:        } while (linePtr != dlPtr->linePtr);
        !          1992:     }
        !          1993:     return dlPtr;
        !          1994: }
        !          1995: 
        !          1996: /*
        !          1997:  *----------------------------------------------------------------------
        !          1998:  *
        !          1999:  * TkTextCharAtLoc --
        !          2000:  *
        !          2001:  *     Given an (x,y) coordinate on the screen, find the location of
        !          2002:  *     the closest character to that location.
        !          2003:  *
        !          2004:  * Results:
        !          2005:  *     The return value is a pointer to the text line containing the
        !          2006:  *     character displayed closest to (x,y).  The value at *chPtr is
        !          2007:  *     overwritten with the index with that line of the closest
        !          2008:  *     character.
        !          2009:  *
        !          2010:  * Side effects:
        !          2011:  *     None.
        !          2012:  *
        !          2013:  *----------------------------------------------------------------------
        !          2014:  */
        !          2015: 
        !          2016: TkTextLine *
        !          2017: TkTextCharAtLoc(textPtr, x, y, chPtr)
        !          2018:     TkText *textPtr;           /* Widget record for text widget. */
        !          2019:     int x, y;                  /* Pixel coordinates of point in widget's
        !          2020:                                 * window. */
        !          2021:     int *chPtr;                        /* Place to store index-within-line of
        !          2022:                                 * closest character. */
        !          2023: {
        !          2024:     DInfo *dInfoPtr = textPtr->dInfoPtr;
        !          2025:     register DLine *dlPtr;
        !          2026:     register Chunk *chunkPtr;
        !          2027:     int count;
        !          2028:     int endX;
        !          2029: 
        !          2030:     /*
        !          2031:      * Make sure that all of the layout information about what's
        !          2032:      * displayed where on the screen is up-to-date.
        !          2033:      */
        !          2034: 
        !          2035:     if (dInfoPtr->flags & DINFO_OUT_OF_DATE) {
        !          2036:        UpdateDisplayInfo(textPtr);
        !          2037:     }
        !          2038: 
        !          2039:     /*
        !          2040:      * If the coordinates are above the top of the window, then adjust
        !          2041:      * them to refer to the upper-right corner of the window.
        !          2042:      */
        !          2043: 
        !          2044:     if (y < dInfoPtr->y) {
        !          2045:        y = dInfoPtr->y;
        !          2046:        x = dInfoPtr->x;
        !          2047:     } else if (y >= dInfoPtr->topOfEof) {
        !          2048:        y = dInfoPtr->topOfEof;
        !          2049:        x = dInfoPtr->maxX;
        !          2050:     }
        !          2051:     for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL; dlPtr = dlPtr->nextPtr) {
        !          2052:        if (y > (dlPtr->y + dlPtr->height)) {
        !          2053:            if (dlPtr->nextPtr != NULL) {
        !          2054:                continue;
        !          2055:            }
        !          2056: 
        !          2057:            /*
        !          2058:             * The coordinates are off the bottom of the window.  Adjust
        !          2059:             * them to refer to the lower-right character on the window.
        !          2060:             */
        !          2061: 
        !          2062:            y = dlPtr->y;
        !          2063:            x = dInfoPtr->maxX;
        !          2064:        }
        !          2065:        for (chunkPtr = dlPtr->chunkPtr; ; chunkPtr = chunkPtr->nextPtr) {
        !          2066:            if ((chunkPtr->nextPtr == NULL) || (chunkPtr->nextPtr->x > x)) {
        !          2067:                break;
        !          2068:            }
        !          2069:        }
        !          2070:        count = TkMeasureChars(chunkPtr->stylePtr->sValuePtr->fontPtr,
        !          2071:            chunkPtr->text, chunkPtr->numChars, chunkPtr->x, x, 0, &endX);
        !          2072:        if (count >= chunkPtr->numChars) {
        !          2073:            /*
        !          2074:             * The point is off the end of the line.  Return the character
        !          2075:             * after the last one that fit, unless that character appears
        !          2076:             * as the first character on the next DLine or unless the last
        !          2077:             * one that fit extends beyond the edge of the window.
        !          2078:             */
        !          2079: 
        !          2080:            if ((dlPtr->nextPtr != NULL)
        !          2081:                    && (dlPtr->nextPtr->chunkPtr->text
        !          2082:                    == (chunkPtr->text + chunkPtr->numChars))) {
        !          2083:                count = chunkPtr->numChars-1;
        !          2084:            }
        !          2085:            if (endX >= dInfoPtr->maxX) {
        !          2086:                count = chunkPtr->numChars-1;
        !          2087:            }
        !          2088:        }
        !          2089:        *chPtr = count + (chunkPtr->text - dlPtr->linePtr->bytes);
        !          2090:        return dlPtr->linePtr;
        !          2091:     }
        !          2092:     panic("TkTextCharAtLoc ran out of lines");
        !          2093:     return (TkTextLine *) NULL;
        !          2094: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.