diff options
Diffstat (limited to 'generic/tkTextDisp.c')
| -rw-r--r-- | generic/tkTextDisp.c | 2421 |
1 files changed, 2044 insertions, 377 deletions
diff --git a/generic/tkTextDisp.c b/generic/tkTextDisp.c index 48f2963..701fe96 100644 --- a/generic/tkTextDisp.c +++ b/generic/tkTextDisp.c @@ -3,7 +3,9 @@ * * This module provides facilities to display text widgets. It is * the only place where information is kept about the screen layout - * of text widgets. + * of text widgets. (Well, strictly, each TkTextLine caches its + * last observed pixel height, but that information is + * calculated here). * * Copyright (c) 1992-1994 The Regents of the University of California. * Copyright (c) 1994-1997 Sun Microsystems, Inc. @@ -11,7 +13,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tkTextDisp.c,v 1.17 2003/07/07 20:39:50 hobbs Exp $ + * RCS: @(#) $Id: tkTextDisp.c,v 1.18 2003/10/31 09:02:10 vincentdarley Exp $ */ #include "tkPort.h" @@ -119,11 +121,15 @@ typedef struct DLine { int y; /* Y-position at which line is supposed to * be drawn (topmost pixel of rectangular * area occupied by line). */ - int oldY; /* Y-position at which line currently - * appears on display. -1 means line isn't - * currently visible on display and must be - * redrawn. This is used to move lines by - * scrolling rather than re-drawing. */ + int oldY; /* Y-position at which line + * currently appears on display. This + * is used to move lines by scrolling + * rather than re-drawing. If 'flags' + * have the OLD_Y_INVALID bit set, then + * we will never examine this field + * (which means line isn't currently + * visible on display and must be + * redrawn). */ int height; /* Height of line, in pixels. */ int baseline; /* Offset of text baseline from y, in * pixels. */ @@ -171,14 +177,20 @@ typedef struct DLine { * BOTTOM_LINE - Non-zero means that this was the bottom line * in the window the last time that the window * was laid out. - * IS_DISABLED - This Dline cannot be edited. + * OLD_Y_INVALID - The value of oldY in the structure is + * not valid or useful and should not be + * examined. 'oldY' is only useful when the + * DLine is currently displayed at a + * different position and we wish to + * re-display it via scrolling, so this + * means the DLine needs redrawing. */ #define HAS_3D_BORDER 1 #define NEW_LAYOUT 2 #define TOP_LINE 4 #define BOTTOM_LINE 8 -#define IS_DISABLED 16 +#define OLD_Y_INVALID 16 /* * Overall display information for a text widget: @@ -189,6 +201,10 @@ typedef struct TextDInfo { * to TextStyles for this widget. */ DLine *dLinePtr; /* First in list of all display lines for * this widget, in order from top to bottom. */ + int topPixelOffset; /* Identifies first pixel in top display + * line to display in window. */ + int newTopPixelOffset; /* Desired first pixel in top display + * line to display in window. */ GC copyGC; /* Graphics context for copying from off- * screen pixmaps onto screen. */ GC scrollGC; /* Graphics context for copying from one place @@ -216,11 +232,11 @@ typedef struct TextDInfo { * Information used for scrolling: */ - int newByteOffset; /* Desired x scroll position, measured as the + int newXByteOffset; /* Desired x scroll position, measured as the * number of average-size characters off-screen * to the left for a line with no left * margin. */ - int curPixelOffset; /* Actual x scroll position, measured as the + int curXPixelOffset; /* Actual x scroll position, measured as the * number of pixels off-screen to the left. */ int maxLength; /* Length in pixels of longest line that's * visible in window (length may exceed window @@ -243,7 +259,7 @@ typedef struct TextDInfo { * left edge of the window when the scan * started. */ int scanMarkX; /* X-position of mouse at time scan started. */ - int scanTotalScroll; /* Total scrolling (in screen lines) that has + int scanTotalYScroll; /* Total scrolling (in screen pixels) that has * occurred since scanMarkY was set. */ int scanMarkY; /* Y-position of mouse at time scan started. */ @@ -264,6 +280,28 @@ typedef struct TextDInfo { * could dump core. */ int flags; /* Various flag values: see below for * definitions. */ + /* + * Information used to handle the asynchronous updating of the + * y-scrollbar and the vertical height calculations: + */ + + int lineMetricUpdateEpoch; /* Stores a number which is incremented + * each time the text widget changes in + * a significant way (e.g. resizing or + * geometry-influencing tag changes). */ + int currentMetricUpdateLine;/* Stores a counter which is used to + * iterate over the logical lines + * contained in the widget and update + * their geometry calculations, if they + * are out of date. */ + int lastMetricUpdateLine; /* When the current update line reaches + * this line, we are done and should + * stop the asychronous callback + * mechanism. */ + Tcl_TimerToken lineUpdateTimer; /* A token pointing to the current + * line metric update callback. */ + Tcl_TimerToken scrollbarTimer; /* A token pointing to the current + * scrollbar update callback. */ } TextDInfo; /* @@ -302,6 +340,20 @@ typedef struct CharInfo { #define REPICK_NEEDED 8 /* + * Action values for FreeDLines: + * + * DLINE_FREE: Free the lines, but no need to unlink them + * from the current list of actual display lines. + * DLINE_UNLINK: Free and unlink from current display. + * DLINE_FREE_TEMP: Free, but don't unlink, and also don't + * set 'dLinesInvalidated'. + */ + +#define DLINE_FREE 0 +#define DLINE_UNLINK 1 +#define DLINE_FREE_TEMP 2 + +/* * The following counters keep statistics about redisplay that can be * checked to see how clever this code is at reducing redisplays. */ @@ -352,33 +404,58 @@ static void DisplayText _ANSI_ARGS_((ClientData clientData)); static DLine * FindDLine _ANSI_ARGS_((DLine *dlPtr, CONST TkTextIndex *indexPtr)); static void FreeDLines _ANSI_ARGS_((TkText *textPtr, - DLine *firstPtr, DLine *lastPtr, int unlink)); + DLine *firstPtr, DLine *lastPtr, int action)); static void FreeStyle _ANSI_ARGS_((TkText *textPtr, TextStyle *stylePtr)); static TextStyle * GetStyle _ANSI_ARGS_((TkText *textPtr, - TkTextIndex *indexPtr)); + CONST TkTextIndex *indexPtr)); static void GetXView _ANSI_ARGS_((Tcl_Interp *interp, TkText *textPtr, int report)); static void GetYView _ANSI_ARGS_((Tcl_Interp *interp, TkText *textPtr, int report)); +static int GetPixelCount _ANSI_ARGS_((TkText *textPtr, + DLine *dlPtr)); static DLine * LayoutDLine _ANSI_ARGS_((TkText *textPtr, - TkTextIndex *indexPtr)); + CONST TkTextIndex *indexPtr)); static int MeasureChars _ANSI_ARGS_((Tk_Font tkfont, CONST char *source, int maxBytes, int startX, int maxX, int tabOrigin, int *nextXPtr)); static void MeasureUp _ANSI_ARGS_((TkText *textPtr, - TkTextIndex *srcPtr, int distance, - TkTextIndex *dstPtr)); + CONST TkTextIndex *srcPtr, int distance, + TkTextIndex *dstPtr, int *overlap)); static int NextTabStop _ANSI_ARGS_((Tk_Font tkfont, int x, int tabOrigin)); static void UpdateDisplayInfo _ANSI_ARGS_((TkText *textPtr)); -static void ScrollByLines _ANSI_ARGS_((TkText *textPtr, +static void YScrollByLines _ANSI_ARGS_((TkText *textPtr, + int offset)); +static void YScrollByPixels _ANSI_ARGS_((TkText *textPtr, int offset)); static int SizeOfTab _ANSI_ARGS_((TkText *textPtr, TkTextTabArray *tabArrayPtr, int index, int x, int maxX)); static void TextInvalidateRegion _ANSI_ARGS_((TkText *textPtr, TkRegion region)); +static int TextCalculateDisplayLineHeight _ANSI_ARGS_(( + TkText *textPtr, CONST TkTextIndex *indexPtr, + int *byteCountPtr)); +static void DlineIndexOfX _ANSI_ARGS_((TkText *textPtr, + DLine *dlPtr, int x, TkTextIndex *indexPtr)); +static int DlineXOfIndex _ANSI_ARGS_((TkText *textPtr, + DLine *dlPtr, int byteIndex)); +static int TextGetScrollInfoObj _ANSI_ARGS_((Tcl_Interp *interp, + TkText *textPtr, int objc, + Tcl_Obj *CONST objv[], double *dblPtr, + int *intPtr)); + +/* + * Result values returned by TextGetScrollInfo: + */ + +#define TKTEXT_SCROLL_MOVETO 1 +#define TKTEXT_SCROLL_PAGES 2 +#define TKTEXT_SCROLL_UNITS 3 +#define TKTEXT_SCROLL_ERROR 4 +#define TKTEXT_SCROLL_PIXELS 5 /* @@ -412,10 +489,10 @@ TkTextCreateDInfo(textPtr) dInfoPtr->copyGC = None; gcValues.graphics_exposures = True; dInfoPtr->scrollGC = Tk_GetGC(textPtr->tkwin, GCGraphicsExposures, - &gcValues); + &gcValues); dInfoPtr->topOfEof = 0; - dInfoPtr->newByteOffset = 0; - dInfoPtr->curPixelOffset = 0; + dInfoPtr->newXByteOffset = 0; + dInfoPtr->curXPixelOffset = 0; dInfoPtr->maxLength = 0; dInfoPtr->xScrollFirst = -1; dInfoPtr->xScrollLast = -1; @@ -423,10 +500,25 @@ TkTextCreateDInfo(textPtr) dInfoPtr->yScrollLast = -1; dInfoPtr->scanMarkIndex = 0; dInfoPtr->scanMarkX = 0; - dInfoPtr->scanTotalScroll = 0; + dInfoPtr->scanTotalYScroll = 0; dInfoPtr->scanMarkY = 0; dInfoPtr->dLinesInvalidated = 0; dInfoPtr->flags = DINFO_OUT_OF_DATE; + dInfoPtr->topPixelOffset = 0; + dInfoPtr->newTopPixelOffset = 0; + dInfoPtr->currentMetricUpdateLine = -1; + dInfoPtr->lastMetricUpdateLine = -1; + dInfoPtr->lineMetricUpdateEpoch = 1; + + /* Add a refCount for each of the idle call-backs */ + textPtr->refCount++; + dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(0, + TkTextAsyncUpdateLineMetrics, (ClientData) textPtr); + textPtr->refCount++; + dInfoPtr->scrollbarTimer = Tcl_CreateTimerHandler(200, + TkTextUpdateYScrollbar, (ClientData) textPtr); + + textPtr->dInfoPtr = dInfoPtr; } @@ -460,7 +552,7 @@ TkTextFreeDInfo(textPtr) * all free then styleTable will be empty. */ - FreeDLines(textPtr, dInfoPtr->dLinePtr, (DLine *) NULL, 1); + FreeDLines(textPtr, dInfoPtr->dLinePtr, (DLine *) NULL, DLINE_UNLINK); Tcl_DeleteHashTable(&dInfoPtr->styleTable); if (dInfoPtr->copyGC != None) { Tk_FreeGC(textPtr->display, dInfoPtr->copyGC); @@ -469,6 +561,16 @@ TkTextFreeDInfo(textPtr) if (dInfoPtr->flags & REDRAW_PENDING) { Tcl_CancelIdleCall(DisplayText, (ClientData) textPtr); } + if (dInfoPtr->lineUpdateTimer != NULL) { + Tcl_DeleteTimerHandler(dInfoPtr->lineUpdateTimer); + textPtr->refCount--; + dInfoPtr->lineUpdateTimer = NULL; + } + if (dInfoPtr->scrollbarTimer != NULL) { + Tcl_DeleteTimerHandler(dInfoPtr->scrollbarTimer); + textPtr->refCount--; + dInfoPtr->scrollbarTimer = NULL; + } ckfree((char *) dInfoPtr); } @@ -493,7 +595,7 @@ TkTextFreeDInfo(textPtr) static TextStyle * GetStyle(textPtr, indexPtr) TkText *textPtr; /* Overall information about text widget. */ - TkTextIndex *indexPtr; /* The character in the text for which + CONST TkTextIndex *indexPtr;/* The character in the text for which * display information is wanted. */ { TkTextTag **tagPtrs; @@ -762,6 +864,22 @@ FreeStyle(textPtr, stylePtr) * * Side effects: * Storage is allocated for the new DLine. + * + * See the comments in 'GetYView' for some thoughts on what the + * side-effects of this call (or its callers) should be -- the + * synchronisation of TkTextLine->pixelHeight with the sum of + * the results of this function operating on all display lines + * within each logical line. Ideally the code should be + * refactored to ensure the cached pixel height is never behind + * what is known when this function is called elsewhere. + * + * Unfortunately, this function is currently called from many + * different places, not just to layout a display line for actual + * display, but also simply to calculate some metric or other of one + * or more display lines (typically the height). It would be a good + * idea to do some profiling of typical text widget usage and the + * way in which this is called and see if some optimization could or + * should be done. * *---------------------------------------------------------------------- */ @@ -769,7 +887,7 @@ FreeStyle(textPtr, stylePtr) static DLine * LayoutDLine(textPtr, indexPtr) TkText *textPtr; /* Overall information about text widget. */ - TkTextIndex *indexPtr; /* Beginning of display line. May not + CONST TkTextIndex *indexPtr;/* Beginning of display line. May not * necessarily point to a character segment. */ { register DLine *dlPtr; /* New display line. */ @@ -825,12 +943,12 @@ LayoutDLine(textPtr, indexPtr) dlPtr->index = *indexPtr; dlPtr->byteCount = 0; dlPtr->y = 0; - dlPtr->oldY = -1; + dlPtr->oldY = 0; /* Only setting this to avoid compiler warnings */ dlPtr->height = 0; dlPtr->baseline = 0; dlPtr->chunkPtr = NULL; dlPtr->nextPtr = NULL; - dlPtr->flags = NEW_LAYOUT; + dlPtr->flags = NEW_LAYOUT | OLD_Y_INVALID; /* * Special case entirely elide line as there may be 1000s or more @@ -900,17 +1018,26 @@ LayoutDLine(textPtr, indexPtr) while (segPtr != NULL) { /* - * Every line still gets at least one chunk due to expectations - * in the rest of the code, but we are able to skip elided portions - * of the line quickly. - * If current chunk is elided and last chunk was too, coalese + * Every logical line still gets at least one chunk due to + * expectations in the rest of the code, but we are able to skip + * elided portions of the line quickly. + * + * If current chunk is elided and last chunk was too, coalese. + * + * This also means that each logical line which is entirely + * elided still gets laid out into a DLine, but with zero height. + * This isn't particularly a problem, but it does seem somewhat + * unnecessary. If/when we fix [Tk Bug 443848] (see below) + * then we will probably have to remove such zero height DLines + * too. */ if (elide && (lastChunkPtr != NULL) && (lastChunkPtr->displayProc == NULL /*ElideDisplayProc*/)) { if ((elidesize = segPtr->size - byteOffset) > 0) { curIndex.byteIndex += elidesize; lastChunkPtr->numBytes += elidesize; - breakByteOffset = lastChunkPtr->breakIndex = lastChunkPtr->numBytes; + breakByteOffset = lastChunkPtr->breakIndex + = lastChunkPtr->numBytes; /* * If have we have a tag toggle, there is a chance * that invisibility state changed, so bail out @@ -990,22 +1117,27 @@ LayoutDLine(textPtr, indexPtr) } chunkPtr->x = x; if (elide && maxBytes) { - /* don't free style here, as other code expects to be able to do that */ - /*breakByteOffset =*/ chunkPtr->breakIndex = chunkPtr->numBytes = maxBytes; + /* + * Don't free style here, as other code expects to be able to + * do that. + */ + /* breakByteOffset =*/ + chunkPtr->breakIndex = chunkPtr->numBytes = maxBytes; chunkPtr->width = 0; chunkPtr->minAscent = chunkPtr->minDescent = chunkPtr->minHeight = 0; - /* would just like to point to canonical empty chunk */ + /* Would just like to point to canonical empty chunk */ chunkPtr->displayProc = (Tk_ChunkDisplayProc *) NULL; chunkPtr->undisplayProc = (Tk_ChunkUndisplayProc *) NULL; chunkPtr->measureProc = ElideMeasureProc; chunkPtr->bboxProc = ElideBboxProc; code = 1; - } else - code = (*segPtr->typePtr->layoutProc)(textPtr, &curIndex, segPtr, + } else { + code = (*segPtr->typePtr->layoutProc)(textPtr, &curIndex, segPtr, byteOffset, maxX-tabSize, maxBytes, noCharsYet, wrapMode, chunkPtr); + } if (code <= 0) { FreeStyle(textPtr, chunkPtr->stylePtr); if (code < 0) { @@ -1029,7 +1161,7 @@ LayoutDLine(textPtr, indexPtr) } break; } - if (chunkPtr->numBytes > 0) { + if (!elide && chunkPtr->numBytes > 0) { noCharsYet = 0; lastCharChunkPtr = chunkPtr; } @@ -1073,6 +1205,16 @@ LayoutDLine(textPtr, indexPtr) if (byteOffset >= segPtr->size) { byteOffset = 0; segPtr = segPtr->nextPtr; + if (elide && segPtr == NULL) { + /* + * An elided section started on this line, and carries on + * until the newline. Currently this forces a new line + * anyway (i.e. even though the newline is elided it + * still takes effect). This is because the code + * currently doesn't allow two or more logical lines to + * appear on the same display line. [Tk Bug #443848] + */ + } } chunkPtr = NULL; @@ -1240,7 +1382,7 @@ UpdateDisplayInfo(textPtr) register DLine *dlPtr, *prevPtr; TkTextIndex index; TkTextLine *lastLinePtr; - int y, maxY, pixelOffset, maxOffset; + int y, maxY, xPixelOffset, maxOffset, lineHeight; if (!(dInfoPtr->flags & DINFO_OUT_OF_DATE)) { return; @@ -1254,7 +1396,12 @@ UpdateDisplayInfo(textPtr) index = textPtr->topIndex; dlPtr = FindDLine(dInfoPtr->dLinePtr, &index); if ((dlPtr != NULL) && (dlPtr != dInfoPtr->dLinePtr)) { - FreeDLines(textPtr, dInfoPtr->dLinePtr, dlPtr, 1); + FreeDLines(textPtr, dInfoPtr->dLinePtr, dlPtr, DLINE_UNLINK); + } + if (index.byteIndex == 0) { + lineHeight = 0; + } else { + lineHeight = -1; } /* @@ -1265,10 +1412,10 @@ UpdateDisplayInfo(textPtr) */ lastLinePtr = TkBTreeFindLine(textPtr->tree, - TkBTreeNumLines(textPtr->tree)); + TkBTreeNumLines(textPtr->tree)); dlPtr = dInfoPtr->dLinePtr; prevPtr = NULL; - y = dInfoPtr->y; + y = dInfoPtr->y - dInfoPtr->newTopPixelOffset; maxY = dInfoPtr->maxY; while (1) { register DLine *newPtr; @@ -1300,6 +1447,7 @@ UpdateDisplayInfo(textPtr) */ if ((dlPtr == NULL) || (dlPtr->index.linePtr != index.linePtr)) { + /* * Case (b) -- must make new DLine. */ @@ -1325,7 +1473,7 @@ UpdateDisplayInfo(textPtr) } else { prevPtr->nextPtr = newPtr; if (prevPtr->flags & HAS_3D_BORDER) { - prevPtr->oldY = -1; + prevPtr->flags |= OLD_Y_INVALID; } } newPtr->nextPtr = dlPtr; @@ -1343,7 +1491,7 @@ UpdateDisplayInfo(textPtr) if ((dlPtr->flags & HAS_3D_BORDER) && (prevPtr != NULL) && (prevPtr->flags & (NEW_LAYOUT))) { - dlPtr->oldY = -1; + dlPtr->flags |= OLD_Y_INVALID; } goto lineOK; } @@ -1357,7 +1505,7 @@ UpdateDisplayInfo(textPtr) */ newPtr = dlPtr->nextPtr; - FreeDLines(textPtr, dlPtr, newPtr, 0); + FreeDLines(textPtr, dlPtr, newPtr, DLINE_FREE); dlPtr = newPtr; if (prevPtr != NULL) { prevPtr->nextPtr = newPtr; @@ -1374,6 +1522,9 @@ UpdateDisplayInfo(textPtr) lineOK: dlPtr->y = y; y += dlPtr->height; + if (lineHeight != -1) { + lineHeight += dlPtr->height; + } TkTextIndexForwBytes(&index, dlPtr->byteCount, &index); prevPtr = dlPtr; dlPtr = dlPtr->nextPtr; @@ -1392,10 +1543,36 @@ UpdateDisplayInfo(textPtr) nextPtr = nextPtr->nextPtr; } if (nextPtr != dlPtr) { - FreeDLines(textPtr, dlPtr, nextPtr, 0); + FreeDLines(textPtr, dlPtr, nextPtr, DLINE_FREE); prevPtr->nextPtr = nextPtr; dlPtr = nextPtr; } + + if ((lineHeight != -1) + && (lineHeight > prevPtr->index.linePtr->pixelHeight)) { + /* + * The logical line height we just calculated is actually + * larger than the currently cached height of the + * text line. That is fine (the text line heights + * are only calculated asynchronously), but we must + * update the cached height so that any counts made + * with DLine pointers do not exceed counts made + * through the BTree. + */ + TkBTreeAdjustPixelHeight(prevPtr->index.linePtr, + lineHeight); + /* + * I believe we can be 100% sure that we started at the + * beginning of the logical line, so we can also adjust + * the 'pixelCalculationEpoch' to mark it as being up to + * date. There is a slight concern that we might not + * have got this right for the first line in the + * re-display. + */ + prevPtr->index.linePtr->pixelCalculationEpoch = + dInfoPtr->lineMetricUpdateEpoch; + } + lineHeight = 0; } /* @@ -1414,75 +1591,135 @@ UpdateDisplayInfo(textPtr) * Delete any DLine structures that don't fit on the screen. */ - FreeDLines(textPtr, dlPtr, (DLine *) NULL, 1); + FreeDLines(textPtr, dlPtr, (DLine *) NULL, DLINE_UNLINK); /* *-------------------------------------------------------------- * If there is extra space at the bottom of the window (because * we've hit the end of the text), then bring in more lines at * the top of the window, if there are any, to fill in the view. + * + * Since the top line may only be partially visible, we try first + * to simply show more pixels from that line (newTopPixelOffset). + * If that isn't enough, we have to layout more lines. *-------------------------------------------------------------- */ if (y < maxY) { - int lineNum, spaceLeft, bytesToCount; - DLine *lowestPtr; - - /* - * Layout an entire text line (potentially > 1 display line), - * then link in as many display lines as fit without moving - * the bottom line out of the window. Repeat this until - * all the extra space has been used up or we've reached the - * beginning of the text. - */ - - spaceLeft = maxY - y; - lineNum = TkBTreeLineIndex(dInfoPtr->dLinePtr->index.linePtr); - bytesToCount = dInfoPtr->dLinePtr->index.byteIndex; - if (bytesToCount == 0) { - bytesToCount = INT_MAX; - lineNum--; - } - for ( ; (lineNum >= 0) && (spaceLeft > 0); lineNum--) { - index.linePtr = TkBTreeFindLine(textPtr->tree, lineNum); - index.byteIndex = 0; - lowestPtr = NULL; - - do { - dlPtr = LayoutDLine(textPtr, &index); - dlPtr->nextPtr = lowestPtr; - lowestPtr = dlPtr; - if (dlPtr->length == 0 && dlPtr->height == 0) { bytesToCount--; break; } /* elide */ - TkTextIndexForwBytes(&index, dlPtr->byteCount, &index); - bytesToCount -= dlPtr->byteCount; - } while ((bytesToCount > 0) - && (index.linePtr == lowestPtr->index.linePtr)); + int spaceLeft = maxY - y; + + if (spaceLeft <= dInfoPtr->newTopPixelOffset) { + /* + * We can full up all the needed space just by showing + * more of the current top line + */ + dInfoPtr->newTopPixelOffset -= spaceLeft; + y += spaceLeft; + spaceLeft = 0; + } else { + int lineNum, bytesToCount; + DLine *lowestPtr; + + /* + * Add in all of the current top line, which won't + * be enough to bring y up to maxY (if it was we + * would be in the 'if' block above). + */ + y += dInfoPtr->newTopPixelOffset; + dInfoPtr->newTopPixelOffset = 0; /* - * Scan through the display lines from the bottom one up to - * the top one. + * Layout an entire text line (potentially > 1 display line), + * then link in as many display lines as fit without moving + * the bottom line out of the window. Repeat this until + * all the extra space has been used up or we've reached the + * beginning of the text. */ - while (lowestPtr != NULL) { - dlPtr = lowestPtr; - spaceLeft -= dlPtr->height; - if (spaceLeft < 0) { - break; + spaceLeft = maxY - y; + lineNum = TkBTreeLineIndex(dInfoPtr->dLinePtr->index.linePtr); + bytesToCount = dInfoPtr->dLinePtr->index.byteIndex; + if (bytesToCount == 0) { + bytesToCount = INT_MAX; + lineNum--; + } + for ( ; (lineNum >= 0) && (spaceLeft > 0); lineNum--) { + int pixelHeight = 0; + + index.linePtr = TkBTreeFindLine(textPtr->tree, lineNum); + index.byteIndex = 0; + lowestPtr = NULL; + + do { + dlPtr = LayoutDLine(textPtr, &index); + pixelHeight += dlPtr->height; + dlPtr->nextPtr = lowestPtr; + lowestPtr = dlPtr; + if (dlPtr->length == 0 && dlPtr->height == 0) { + bytesToCount--; break; + } /* elide */ + TkTextIndexForwBytes(&index, dlPtr->byteCount, &index); + bytesToCount -= dlPtr->byteCount; + } while ((bytesToCount > 0) + && (index.linePtr == lowestPtr->index.linePtr)); + + /* + * We may not have examined the entire line (depending + * on the value of 'bytesToCount', so we only want + * to set this if it is genuinely bigger). + */ + if (pixelHeight > lowestPtr->index.linePtr->pixelHeight) { + TkBTreeAdjustPixelHeight(lowestPtr->index.linePtr, + pixelHeight); + if (index.linePtr != lowestPtr->index.linePtr) { + /* + * We examined the entire line, so can update + * the epoch. + */ + lowestPtr->index.linePtr->pixelCalculationEpoch = + dInfoPtr->lineMetricUpdateEpoch; + } } - lowestPtr = dlPtr->nextPtr; - dlPtr->nextPtr = dInfoPtr->dLinePtr; - dInfoPtr->dLinePtr = dlPtr; - if (tkTextDebug) { - char string[TK_POS_CHARS]; - TkTextPrintIndex(&dlPtr->index, string); - Tcl_SetVar2(textPtr->interp, "tk_textRelayout", + /* + * Scan through the display lines from the bottom one up to + * the top one. + */ + + while (lowestPtr != NULL) { + dlPtr = lowestPtr; + spaceLeft -= dlPtr->height; + lowestPtr = dlPtr->nextPtr; + dlPtr->nextPtr = dInfoPtr->dLinePtr; + dInfoPtr->dLinePtr = dlPtr; + if (tkTextDebug) { + char string[TK_POS_CHARS]; + + TkTextPrintIndex(&dlPtr->index, string); + Tcl_SetVar2(textPtr->interp, "tk_textRelayout", (char *) NULL, string, TCL_GLOBAL_ONLY|TCL_APPEND_VALUE|TCL_LIST_ELEMENT); + } + if (spaceLeft <= 0) { + break; + } + } + FreeDLines(textPtr, lowestPtr, (DLine *) NULL, DLINE_FREE); + bytesToCount = INT_MAX; + } + /* + * We've filled in the space we wanted to, and we + * need to store any extra overlap we've just + * created for the top line. + */ + if (lineNum >= 0) { + dInfoPtr->newTopPixelOffset = -spaceLeft; + if (spaceLeft > 0 + || dInfoPtr->newTopPixelOffset >= dInfoPtr->dLinePtr->height) { + /* Bad situation */ + panic("Pixel height problem while laying out text widget"); } } - FreeDLines(textPtr, lowestPtr, (DLine *) NULL, 0); - bytesToCount = INT_MAX; } /* @@ -1492,7 +1729,7 @@ UpdateDisplayInfo(textPtr) */ textPtr->topIndex = dInfoPtr->dLinePtr->index; - y = dInfoPtr->y; + y = dInfoPtr->y - dInfoPtr->newTopPixelOffset; for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL; dlPtr = dlPtr->nextPtr) { if (y > dInfoPtr->maxY) { @@ -1517,21 +1754,30 @@ UpdateDisplayInfo(textPtr) dlPtr = dInfoPtr->dLinePtr; if ((dlPtr->flags & HAS_3D_BORDER) && !(dlPtr->flags & TOP_LINE)) { - dlPtr->oldY = -1; + dlPtr->flags |= OLD_Y_INVALID; } while (1) { if ((dlPtr->flags & TOP_LINE) && (dlPtr != dInfoPtr->dLinePtr) && (dlPtr->flags & HAS_3D_BORDER)) { - dlPtr->oldY = -1; + dlPtr->flags |= OLD_Y_INVALID; + } + /* + * If the old top-line was not completely showing (i.e. the + * pixelOffset is non-zero) and is no longer the top-line, then + * we must re-draw it. + */ + if ((dlPtr->flags & TOP_LINE) + && (dInfoPtr->topPixelOffset != 0) && (dlPtr != dInfoPtr->dLinePtr)) { + dlPtr->flags |= OLD_Y_INVALID; } if ((dlPtr->flags & BOTTOM_LINE) && (dlPtr->nextPtr != NULL) && (dlPtr->flags & HAS_3D_BORDER)) { - dlPtr->oldY = -1; + dlPtr->flags |= OLD_Y_INVALID; } if (dlPtr->nextPtr == NULL) { if ((dlPtr->flags & HAS_3D_BORDER) && !(dlPtr->flags & BOTTOM_LINE)) { - dlPtr->oldY = -1; + dlPtr->flags |= OLD_Y_INVALID; } dlPtr->flags &= ~TOP_LINE; dlPtr->flags |= BOTTOM_LINE; @@ -1541,6 +1787,7 @@ UpdateDisplayInfo(textPtr) dlPtr = dlPtr->nextPtr; } dInfoPtr->dLinePtr->flags |= TOP_LINE; + dInfoPtr->topPixelOffset = dInfoPtr->newTopPixelOffset; /* * Arrange for scrollbars to be updated. @@ -1569,18 +1816,18 @@ UpdateDisplayInfo(textPtr) } maxOffset = (dInfoPtr->maxLength - (dInfoPtr->maxX - dInfoPtr->x) + textPtr->charWidth - 1)/textPtr->charWidth; - if (dInfoPtr->newByteOffset > maxOffset) { - dInfoPtr->newByteOffset = maxOffset; + if (dInfoPtr->newXByteOffset > maxOffset) { + dInfoPtr->newXByteOffset = maxOffset; } - if (dInfoPtr->newByteOffset < 0) { - dInfoPtr->newByteOffset = 0; + if (dInfoPtr->newXByteOffset < 0) { + dInfoPtr->newXByteOffset = 0; } - pixelOffset = dInfoPtr->newByteOffset * textPtr->charWidth; - if (pixelOffset != dInfoPtr->curPixelOffset) { - dInfoPtr->curPixelOffset = pixelOffset; + xPixelOffset = dInfoPtr->newXByteOffset * textPtr->charWidth; + if (xPixelOffset != dInfoPtr->curXPixelOffset) { + dInfoPtr->curXPixelOffset = xPixelOffset; for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL; dlPtr = dlPtr->nextPtr) { - dlPtr->oldY = -1; + dlPtr->flags |= OLD_Y_INVALID; } } } @@ -1603,23 +1850,29 @@ UpdateDisplayInfo(textPtr) */ static void -FreeDLines(textPtr, firstPtr, lastPtr, unlink) - TkText *textPtr; /* Information about overall text - * widget. */ - register DLine *firstPtr; /* Pointer to first DLine to free up. */ - DLine *lastPtr; /* Pointer to DLine just after last - * one to free (NULL means everything - * starting with firstPtr). */ - int unlink; /* 1 means DLines are currently linked - * into the list rooted at - * textPtr->dInfoPtr->dLinePtr and - * they have to be unlinked. 0 means - * just free without unlinking. */ +FreeDLines(textPtr, firstPtr, lastPtr, action) + TkText *textPtr; /* Information about overall text + * widget. */ + register DLine *firstPtr; /* Pointer to first DLine to free up. */ + DLine *lastPtr; /* Pointer to DLine just after last + * one to free (NULL means everything + * starting with firstPtr). */ + int action; /* DLINE_UNLINK means DLines are + * currently linked into the list + * rooted at + * textPtr->dInfoPtr->dLinePtr and + * they have to be unlinked. + * DLINE_FREE means just free without + * unlinking. DLINE_FREE_TEMP means + * the DLine given is just a + * temporary one and we shouldn't + * invalidate anything for the + * overall widget. */ { register TkTextDispChunk *chunkPtr, *nextChunkPtr; register DLine *nextDLinePtr; - if (unlink) { + if (action == DLINE_UNLINK) { if (textPtr->dInfoPtr->dLinePtr == firstPtr) { textPtr->dInfoPtr->dLinePtr = lastPtr; } else { @@ -1645,7 +1898,9 @@ FreeDLines(textPtr, firstPtr, lastPtr, unlink) ckfree((char *) firstPtr); firstPtr = nextDLinePtr; } - textPtr->dInfoPtr->dLinesInvalidated = 1; + if (action != DLINE_FREE_TEMP) { + textPtr->dInfoPtr->dLinesInvalidated = 1; + } } /* @@ -1680,7 +1935,7 @@ DisplayDLine(textPtr, dlPtr, prevPtr, pixmap) register TkTextDispChunk *chunkPtr; TextDInfo *dInfoPtr = textPtr->dInfoPtr; Display *display; - int height, x; + int height, y_off; if (dlPtr->chunkPtr == NULL) return; @@ -1710,8 +1965,8 @@ DisplayDLine(textPtr, dlPtr, prevPtr, pixmap) if (textPtr->state == TK_TEXT_STATE_NORMAL) { for (chunkPtr = dlPtr->chunkPtr; (chunkPtr != NULL); chunkPtr = chunkPtr->nextPtr) { - x = chunkPtr->x + dInfoPtr->x - dInfoPtr->curPixelOffset; if (chunkPtr->displayProc == TkTextInsertDisplayProc) { + int x = chunkPtr->x + dInfoPtr->x - dInfoPtr->curXPixelOffset; (*chunkPtr->displayProc)(chunkPtr, x, dlPtr->spaceAbove, dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow, dlPtr->baseline - dlPtr->spaceAbove, display, pixmap, @@ -1725,7 +1980,6 @@ DisplayDLine(textPtr, dlPtr, prevPtr, pixmap) * foreground information. Note: we have to call the displayProc * even for chunks that are off-screen. This is needed, for * example, so that embedded windows can be unmapped in this case. - * Conve */ for (chunkPtr = dlPtr->chunkPtr; (chunkPtr != NULL); @@ -1738,54 +1992,59 @@ DisplayDLine(textPtr, dlPtr, prevPtr, pixmap) continue; } - x = chunkPtr->x + dInfoPtr->x - dInfoPtr->curPixelOffset; - if ((x + chunkPtr->width <= 0) || (x >= dInfoPtr->maxX)) { - /* - * Note: we have to call the displayProc even for chunks - * that are off-screen. This is needed, for example, so - * that embedded windows can be unmapped in this case. - * Display the chunk at a coordinate that can be clearly - * identified by the displayProc as being off-screen to - * the left (the displayProc may not be able to tell if - * something is off to the right). - */ + /* + * Don't call if elide. This tax ok since not very many + * visible DLine's in an area, but potentially many elide + * ones + */ + if (chunkPtr->displayProc != NULL) { + int x = chunkPtr->x + dInfoPtr->x - dInfoPtr->curXPixelOffset; - if (chunkPtr->displayProc != NULL) - (*chunkPtr->displayProc)(chunkPtr, -chunkPtr->width, - dlPtr->spaceAbove, - dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow, - dlPtr->baseline - dlPtr->spaceAbove, display, pixmap, - dlPtr->y + dlPtr->spaceAbove); - } else { - /* don't call if elide. This tax ok since not very many visible DLine's in - an area, but potentially many elide ones */ - if (chunkPtr->displayProc != NULL) + if ((x + chunkPtr->width <= 0) || (x >= dInfoPtr->maxX)) { + /* + * Note: we have to call the displayProc even for chunks + * that are off-screen. This is needed, for example, so + * that embedded windows can be unmapped in this case. + * Display the chunk at a coordinate that can be clearly + * identified by the displayProc as being off-screen to + * the left (the displayProc may not be able to tell if + * something is off to the right). + */ + x = -chunkPtr->width; + } (*chunkPtr->displayProc)(chunkPtr, x, dlPtr->spaceAbove, dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow, dlPtr->baseline - dlPtr->spaceAbove, display, pixmap, dlPtr->y + dlPtr->spaceAbove); } + if (dInfoPtr->dLinesInvalidated) { return; } } /* - * Copy the pixmap onto the screen. If this is the last line on - * the screen then copy a piece of the line, so that it doesn't - * overflow into the border area. Another special trick: copy the - * padding area to the left of the line; this is because the - * insertion cursor sometimes overflows onto that area and we want - * to get as much of the cursor as possible. + * Copy the pixmap onto the screen. If this is the first or last + * line on the screen then copy a piece of the line, so that it + * doesn't overflow into the border area. Another special trick: + * copy the padding area to the left of the line; this is because the + * insertion cursor sometimes overflows onto that area and we want to + * get as much of the cursor as possible. */ height = dlPtr->height; if ((height + dlPtr->y) > dInfoPtr->maxY) { height = dInfoPtr->maxY - dlPtr->y; } + if (dlPtr->y < dInfoPtr->y) { + y_off = dInfoPtr->y - dlPtr->y; + height -= y_off; + } else { + y_off = 0; + } XCopyArea(display, pixmap, Tk_WindowId(textPtr->tkwin), dInfoPtr->copyGC, - dInfoPtr->x, 0, (unsigned) (dInfoPtr->maxX - dInfoPtr->x), - (unsigned) height, dInfoPtr->x, dlPtr->y); + dInfoPtr->x, y_off, (unsigned) (dInfoPtr->maxX - dInfoPtr->x), + (unsigned) height, dInfoPtr->x, dlPtr->y + y_off); linesRedrawn++; } @@ -1857,7 +2116,7 @@ DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap) */ display = Tk_Display(textPtr->tkwin); - minX = dInfoPtr->curPixelOffset; + minX = dInfoPtr->curXPixelOffset; xOffset = dInfoPtr->x - minX; maxX = minX + dInfoPtr->maxX - dInfoPtr->x; chunkPtr = dlPtr->chunkPtr; @@ -2158,6 +2417,692 @@ DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap) /* *---------------------------------------------------------------------- * + * TkTextAsyncUpdateLineMetrics -- + * + * This procedure is invoked as a background handler to update the + * pixel-height calculations of individual lines in an + * asychronous manner. + * + * Currently a timer-handler is used for this purpose, which + * continuously reschedules itself. It may well be better to + * use some other approach (e.g. a background thread). We can't + * use an idle-callback because of a known bug in Tcl/Tk in + * which idle callbacks are not allowed to re-schedule + * themselves. This just causes an effective infinite loop. + * + * Results: + * None. + * + * Side effects: + * Line heights may be recalculated. + * + *---------------------------------------------------------------------- + */ + +void +TkTextAsyncUpdateLineMetrics(clientData) + ClientData clientData; /* Information about widget. */ +{ + register TkText *textPtr = (TkText *) clientData; + TextDInfo *dInfoPtr = textPtr->dInfoPtr; + int lineNum; + + dInfoPtr->lineUpdateTimer = NULL; + + if ((textPtr->tkwin == NULL) || (textPtr->flags & DESTROYED)) { + + /* + * The widget has been deleted. Don't do anything. + */ + + if (--textPtr->refCount == 0) { + ckfree((char *) textPtr); + } + return; + } + + lineNum = dInfoPtr->currentMetricUpdateLine; + if (lineNum == -1) { + dInfoPtr->lastMetricUpdateLine = 0; + } + /* + * Update the lines in blocks of about 24 recalculations, + * or 250+ lines examined, so we pass in 256 for 'doThisMuch'. + */ + lineNum = TkTextUpdateLineMetrics(textPtr, lineNum, + dInfoPtr->lastMetricUpdateLine, 256); + if (lineNum == dInfoPtr->lastMetricUpdateLine) { + /* + * We have looped over all lines, so we're done. We must + * release our refCount on the widget (the timer token + * was already set to NULL above). + */ + textPtr->refCount--; + if (textPtr->refCount == 0) { + ckfree((char *) textPtr); + } + return; + } + dInfoPtr->currentMetricUpdateLine = lineNum; + /* + * Re-arm the timer. We already have a refCount on the text widget + * so no need to adjust that. + */ + dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(1, + TkTextAsyncUpdateLineMetrics, (ClientData) textPtr); +} + +/* + *---------------------------------------------------------------------- + * + * TkTextUpdateLineMetrics -- + * + * This procedure updates the pixel height calculations of a + * range of lines in the widget. The range is from lineNum to + * endLine, but, if doThisMuch is positive, then the procedure + * may return earlier, once a certain number of lines has been + * examined. The line counts are from 0. + * + * If doThisMuch is -1, then all lines in the range will be + * updated. This will potentially take quite some time for + * a large text widget. + * + * Note: with bad input for lineNum and endLine, this procedure can + * loop indefinitely. + * + * Results: + * The index of the last line examined (or -1 if we are about to + * wrap around from end to beginning of the widget, and the next + * line will be the first line). + * + * Side effects: + * Line heights may be recalculated. + * + *---------------------------------------------------------------------- + */ + +int +TkTextUpdateLineMetrics(textPtr, lineNum, endLine, doThisMuch) + TkText *textPtr; /* Information about widget. */ + int lineNum; /* Start at this line */ + int endLine; /* Go no further than this line */ + int doThisMuch; /* How many lines to check, or how many 10s of + * lines to recalculate. If '-1' then do + * everything in the range (which may take a + * while). */ +{ + TkTextLine *linePtr = NULL; + int count = 0; + int totalLines = TkBTreeNumLines(textPtr->tree); + + while (1) { + /* Get a suitable line */ + if (lineNum == -1 && linePtr == NULL) { + lineNum = 0; + linePtr = TkBTreeFindLine(textPtr->tree, lineNum); + } else { + if (lineNum == -1 || linePtr == NULL) { + if (lineNum == -1) { + lineNum = 0; + } + linePtr = TkBTreeFindLine(textPtr->tree, lineNum); + } else { + lineNum++; + linePtr = TkBTreeNextLine(linePtr); + } + if (lineNum == endLine) { + /* + * We have looped over all lines, so we're done. + */ + break; + } + } + + if (lineNum < totalLines) { + /* Now update the line's metrics if necessary */ + if (linePtr->pixelCalculationEpoch + != textPtr->dInfoPtr->lineMetricUpdateEpoch) { + /* + * Update the line and update the counter, counting + * 10 for each line we actually re-layout. + */ + TkTextUpdateOneLine(textPtr, linePtr); + count += 10; + } + } else { + /* + * We must never recalculate the height of the + * last artificial line. It must stay at zero, and + * if we recalculate it, it will change. + */ + + if (endLine >= totalLines) { + break; + } + /* Set things up for the next loop through */ + lineNum = -1; + } + count++; + + if (doThisMuch != -1 && count >= doThisMuch) { + break; + } + } + if (doThisMuch == -1) { + /* + * If we were requested to provide a full update, + * then also update the scrollbar. + */ + GetYView(textPtr->interp, textPtr, 1); + } + return lineNum; +} + +/* + *---------------------------------------------------------------------- + * + * TkTextInvalidateLineMetrics -- + * + * Mark a number of text lines as having invalid line metric + * calculations. Never call this with linePtr as the last + * (artificial) line in the text. Depending on 'action' which + * indicates whether the given lines are simply invalid or have + * been inserted or deleted, the pre-existing asynchronous line + * update range may need to be adjusted. + * + * If linePtr is NULL then 'lineCount' and 'action' are ignored and + * all lines are invalidated. + * + * Results: + * None. + * + * Side effects: + * May schedule an asychronous callback. + * + *---------------------------------------------------------------------- + */ + +void +TkTextInvalidateLineMetrics(textPtr, linePtr, lineCount, action) + TkText *textPtr; /* Widget record for text widget. */ + TkTextLine *linePtr; /* Invalidation starts from this line. */ + int lineCount; /* And includes this many following + * lines. */ + int action; /* Indicates what type of invalidation + * occurred (insert, delete, or + * simple). */ +{ + int fromLine; + TextDInfo *dInfoPtr = textPtr->dInfoPtr; + + if (linePtr != NULL) { + int counter = lineCount; + + fromLine = TkBTreeLineIndex(linePtr); + + /* + * Invalid the height calculations of each line in the + * given range. + */ + linePtr->pixelCalculationEpoch = 0; + while (counter > 0 && linePtr != 0) { + linePtr = TkBTreeNextLine(linePtr); + if (linePtr != NULL) { + linePtr->pixelCalculationEpoch = 0; + } + counter--; + } + /* + * Now schedule an examination of each line in the union of the + * old and new update ranges, including the (possibly empty) + * range in between. If that between range is not-empty, then we + * are examining more lines than is strictly necessary (but the + * examination of the extra lines should be quick, since their + * pixelCalculationEpoch will be up to date). However, to keep + * track of that would require more complex record-keeping that + * what we have. + */ + if (dInfoPtr->lineUpdateTimer == NULL) { + dInfoPtr->currentMetricUpdateLine = fromLine; + if (action == TK_TEXT_INVALIDATE_DELETE) { + lineCount = 0; + } + dInfoPtr->lastMetricUpdateLine = fromLine + lineCount + 1; + } else { + int toLine = fromLine + lineCount + 1; + + if (action == TK_TEXT_INVALIDATE_DELETE) { + if (toLine <= dInfoPtr->currentMetricUpdateLine) { + dInfoPtr->currentMetricUpdateLine = fromLine; + if (dInfoPtr->lastMetricUpdateLine != -1) { + dInfoPtr->lastMetricUpdateLine -= lineCount; + } + } else if (fromLine <= dInfoPtr->currentMetricUpdateLine) { + dInfoPtr->currentMetricUpdateLine = fromLine; + if (toLine <= dInfoPtr->lastMetricUpdateLine) { + dInfoPtr->lastMetricUpdateLine -= lineCount; + } + } else { + if (dInfoPtr->lastMetricUpdateLine != -1) { + dInfoPtr->lastMetricUpdateLine = toLine; + } + } + } else if (action == TK_TEXT_INVALIDATE_INSERT) { + if (toLine <= dInfoPtr->currentMetricUpdateLine) { + dInfoPtr->currentMetricUpdateLine = fromLine; + if (dInfoPtr->lastMetricUpdateLine != -1) { + dInfoPtr->lastMetricUpdateLine += lineCount; + } + } else if (fromLine <= dInfoPtr->currentMetricUpdateLine) { + dInfoPtr->currentMetricUpdateLine = fromLine; + if (toLine <= dInfoPtr->lastMetricUpdateLine) { + dInfoPtr->lastMetricUpdateLine += lineCount; + } + if (toLine > dInfoPtr->lastMetricUpdateLine) { + dInfoPtr->lastMetricUpdateLine = toLine; + } + } else { + if (dInfoPtr->lastMetricUpdateLine != -1) { + dInfoPtr->lastMetricUpdateLine = toLine; + } + } + } else { + if (fromLine < dInfoPtr->currentMetricUpdateLine) { + dInfoPtr->currentMetricUpdateLine = fromLine; + } + if (dInfoPtr->lastMetricUpdateLine != -1 + && toLine > dInfoPtr->lastMetricUpdateLine) { + dInfoPtr->lastMetricUpdateLine = toLine; + } + } + } + } else { + /* + * This invalidates the height of all lines in the widget. + */ + if ((++dInfoPtr->lineMetricUpdateEpoch) == 0) { + dInfoPtr->lineMetricUpdateEpoch++; + } + /* + * This has the effect of forcing an entire new loop + * of update checks on all lines in the widget. + */ + if (dInfoPtr->lineUpdateTimer == NULL) { + dInfoPtr->currentMetricUpdateLine = -1; + } + dInfoPtr->lastMetricUpdateLine = dInfoPtr->currentMetricUpdateLine; + } + + /* + * Now re-set the current update calculations + */ + if (dInfoPtr->lineUpdateTimer == NULL) { + textPtr->refCount++; + dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(1, + TkTextAsyncUpdateLineMetrics, (ClientData) textPtr); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkTextFindDisplayLineEnd -- + * + * This procedure is invoked to find the index of the beginning or + * end of the particular display line on which the given index sits, + * whether that line is displayed or not. + * + * If 'end' is zero, we look for the start, and if 'end' is one + * we look for the end. + * + * If the beginning of the current display line is elided, and we + * are looking for the start of the line, then the returned index + * will be the first elided index on the display line. + * + * Similarly if the end of the current display line is elided + * and we are looking for the end, then the returned index will + * be the last elided index on the display line. (NB. This also + * highlights a current bug in the text widget that we cannot + * place two logical lines on a single display line -- even + * though the newline in this case is elided, it still causes + * a line break to be shown). + * + * Results: + * Modifies indexPtr to point to the given end. + * + * If xOffset is non-NULL, it is set to the x-pixel offset of the + * given original index within the given display line. + * + * Side effects: + * The combination of 'LayoutDLine' and 'FreeDLines' seems + * like a rather time-consuming way of gathering the information + * we need, so this would be a good place to look to speed up + * the calculations. In particular these calls will map and + * unmap embedded windows respectively, which I would hope isn't + * exactly necessary! + * + *---------------------------------------------------------------------- + */ + +void +TkTextFindDisplayLineEnd(textPtr, indexPtr, end, xOffset) + TkText *textPtr; /* Widget record for text widget. */ + TkTextIndex *indexPtr; /* Index we will adjust to the display + * line start or end. */ + int end; /* 0 = start, 1 = end. */ + int *xOffset; /* NULL, or used to store the x-pixel + * offset of the original index within + * its display line. */ +{ + if (!end && indexPtr->byteIndex == 0) { + /* Nothing to do */ + if (xOffset != NULL) { + *xOffset = 0; + } + return; + } else { + TkTextIndex index = *indexPtr; + index.byteIndex = 0; + index.textPtr = NULL; + + while (1) { + DLine *dlPtr; + int byteCount; + + dlPtr = LayoutDLine(textPtr, &index); + byteCount = dlPtr->byteCount; + + /* + * 'byteCount' goes up to the beginning of the next line, + * so equality here says we need one more line + */ + if (index.byteIndex + byteCount > indexPtr->byteIndex) { + /* It's on this display line */ + if (xOffset != NULL) { + /* + * This call takes a byte index relative to the + * start of the current _display_ line, not + * logical line. We are about to overwrite + * indexPtr->byteIndex, so we must do this now. + */ + *xOffset = DlineXOfIndex(textPtr, dlPtr, + indexPtr->byteIndex - dlPtr->index.byteIndex); + } + indexPtr->byteIndex = index.byteIndex; + if (end) { + /* + * The index we want is one less than the number + * of bytes in the display line. + */ + indexPtr->byteIndex += byteCount - sizeof(char); + } + FreeDLines(textPtr, dlPtr, NULL, DLINE_FREE_TEMP); + return; + } + FreeDLines(textPtr, dlPtr, NULL, DLINE_FREE_TEMP); + TkTextIndexForwBytes(&index, byteCount, &index); + } + } +} + +/* + *---------------------------------------------------------------------- + * + * TextCalculateDisplayLineHeight -- + * + * This procedure is invoked to recalculate the height of the + * particular display line which starts with the given index, + * whether that line is displayed or not. + * + * This procedure does not, in itself, update any cached + * information about line heights. That should be done, where + * necessary, by its callers. + * + * The behaviour of this procedure is _undefined_ if indexPtr + * is not currently at the beginning of a display line. + * + * Results: + * The number of vertical pixels used by the display line. + * + * If 'byteCountPtr' is non-NULL, then returns in that pointer + * the number of byte indices on the given display line (which + * can be used to update indexPtr in a loop). + * + * Side effects: + * The combination of 'LayoutDLine' and 'FreeDLines' seems + * like a rather time-consuming way of gathering the information + * we need, so this would be a good place to look to speed up + * the calculations. In particular these calls will map and + * unmap embedded windows respectively, which I would hope isn't + * exactly necessary! + * + *---------------------------------------------------------------------- + */ + +static int +TextCalculateDisplayLineHeight(textPtr, indexPtr, byteCountPtr) + TkText *textPtr; /* Widget record for text widget. */ + CONST TkTextIndex *indexPtr; /* The index at the beginning of the + * display line of interest. */ + int *byteCountPtr; /* NULL or used to return the number of + * byte indices on the given display + * line. */ +{ + DLine *dlPtr; + int pixelHeight; + + /* + * Layout, find the information we need and then free the + * display-line we laid-out. We must use 'FreeDLines' because it + * will actually call the relevant code to unmap any embedded windows + * which were mapped in the LayoutDLine call! + */ + dlPtr = LayoutDLine(textPtr, indexPtr); + pixelHeight = dlPtr->height; + if (byteCountPtr != NULL) { + *byteCountPtr = dlPtr->byteCount; + } + FreeDLines(textPtr, dlPtr, NULL, DLINE_FREE_TEMP); + + return pixelHeight; +} + +/* + *---------------------------------------------------------------------- + * + * TkTextIndexYPixels -- + * + * This procedure is invoked to calculate the number of vertical + * pixels between the first index of the text widget and the given + * index. The range from first logical line to given logical + * line is determined using the cached values, and the range + * inside the given logical line is calculated on the fly. + * + * Results: + * The pixel distance between first pixel in the widget and the + * top of the index's current display line (could be zero). + * + * Side effects: + * Just those of 'TextCalculateDisplayLineHeight'. + * + *---------------------------------------------------------------------- + */ + +int +TkTextIndexYPixels(textPtr, indexPtr) + TkText *textPtr; /* Widget record for text widget. */ + CONST TkTextIndex *indexPtr; /* The index of which we want the pixel + * distance from top of logical line to + * top of index. */ +{ + int pixelHeight; + TkTextIndex index; + + pixelHeight = TkBTreePixels(indexPtr->linePtr); + + /* + * Iterate through all display-lines corresponding to the single + * logical line belonging to indexPtr, adding up the pixel height of + * each such display line as we go along, until we go past + * 'indexPtr'. + */ + + if (indexPtr->byteIndex == 0) { + return pixelHeight; + } + + index.tree = textPtr->tree; + index.linePtr = indexPtr->linePtr; + index.byteIndex = 0; + index.textPtr = NULL; + + while (1) { + int bytes, height; + + /* + * Currently this call doesn't have many side-effects. + * However, if in the future we change the code so there + * are side-effects (such as adjusting linePtr->pixelHeight), + * then the code might not quite work as intended, + * specifically the 'linePtr->pixelHeight == pixelHeight' test + * below this while loop. + */ + height = TextCalculateDisplayLineHeight(textPtr, &index, &bytes); + + index.byteIndex += bytes; + + if (index.byteIndex > indexPtr->byteIndex) { + return pixelHeight; + } + + if (height > 0) { + pixelHeight += height; + } + + if (index.byteIndex == indexPtr->byteIndex) { + return pixelHeight; + } + } +} + +/* + *---------------------------------------------------------------------- + * + * TkTextUpdateOneLine -- + * + * This procedure is invoked to recalculate the height of a + * particular logical line, whether that line is displayed or not. + * + * It must NEVER be called for the artificial last TkTextLine + * which is used internally for administrative purposes only. + * That line must retain its initial height of 0 otherwise + * the pixel height calculation maintained by the B-tree will + * be wrong. + * + * Results: + * The number of display lines in the logical line. This could + * be zero if the line is totally elided. + * + * Side effects: + * Line heights may be recalculated, and a timer to update + * the scrollbar may be installed. Also see the called + * function 'TextCalculateDisplayLineHeight' for its side + * effects. + * + *---------------------------------------------------------------------- + */ + +int +TkTextUpdateOneLine(textPtr, linePtr) + TkText *textPtr; /* Widget record for text widget. */ + TkTextLine *linePtr; /* The line of which to calculate the + * height. */ +{ + TkTextIndex index; + int pixelHeight, displayLines; + + index.tree = textPtr->tree; + index.linePtr = linePtr; + index.byteIndex = 0; + index.textPtr = NULL; + + /* + * Iterate through all display-lines corresponding to the + * single logical line 'linePtr', adding up the pixel height + * of each such display line as we go along. The final + * total is, therefore, the height of the logical line. + */ + + pixelHeight = 0; + displayLines = 0; + + while (1) { + int bytes, height; + + /* + * Currently this call doesn't have many side-effects. + * However, if in the future we change the code so there + * are side-effects (such as adjusting linePtr->pixelHeight), + * then the code might not quite work as intended, + * specifically the 'linePtr->pixelHeight == pixelHeight' test + * below this while loop. + */ + height = TextCalculateDisplayLineHeight(textPtr, &index, &bytes); + + if (height > 0) { + pixelHeight += height; + displayLines++; + } + + if (TkTextIndexForwBytes(&index, bytes, &index)) { + break; + } + + if (index.linePtr != linePtr) { + break; + } + } + + /* + * Mark the logical line as being up to date (caution: it isn't + * yet up to date, that will happen in TkBTreeAdjustPixelHeight + * just below). + */ + linePtr->pixelCalculationEpoch = textPtr->dInfoPtr->lineMetricUpdateEpoch; + + if (linePtr->pixelHeight == pixelHeight) { + return displayLines; + } + + /* + * We now use the resulting 'pixelHeight' to refer to the + * height of the entire widget, which may be used just below + * for reporting/debugging purposes + */ + pixelHeight = TkBTreeAdjustPixelHeight(linePtr, pixelHeight); + + if (tkTextDebug) { + char buffer[TCL_INTEGER_SPACE + 1]; + + if (TkBTreeNextLine(linePtr) == NULL) { + panic("Mustn't ever update line height of last artificial line"); + } + + sprintf(buffer, "%d", pixelHeight); + Tcl_SetVar2(textPtr->interp, "tk_textNumPixels", (char *) NULL, + buffer, TCL_GLOBAL_ONLY); + } + if (textPtr->dInfoPtr->scrollbarTimer == NULL) { + textPtr->refCount++; + textPtr->dInfoPtr->scrollbarTimer = Tcl_CreateTimerHandler(200, + TkTextUpdateYScrollbar, (ClientData) textPtr); + } + return displayLines; +} + +/* + *---------------------------------------------------------------------- + * * DisplayText -- * * This procedure is invoked as a when-idle handler to update the @@ -2243,14 +3188,16 @@ DisplayText(clientData) */ while (dInfoPtr->flags & REPICK_NEEDED) { - Tcl_Preserve((ClientData) textPtr); + textPtr->refCount++; dInfoPtr->flags &= ~REPICK_NEEDED; TkTextPickCurrent(textPtr, &textPtr->pickEvent); + if (--textPtr->refCount == 0) { + ckfree((char *) textPtr); + goto end; + } if ((textPtr->tkwin == NULL) || (textPtr->flags & DESTROYED)) { - Tcl_Release((ClientData) textPtr); goto end; } - Tcl_Release((ClientData) textPtr); } /* @@ -2262,7 +3209,10 @@ DisplayText(clientData) /* * See if it's possible to bring some parts of the screen up-to-date - * by scrolling (copying from other parts of the screen). + * by scrolling (copying from other parts of the screen). We have + * to be particularly careful with the top and bottom lines of the + * display, since these may only be partially visible and therefore + * not helpful for some scrolling purposes. */ for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL; dlPtr = dlPtr->nextPtr) { @@ -2270,8 +3220,30 @@ DisplayText(clientData) int offset, height, y, oldY; TkRegion damageRgn; - if ((dlPtr->oldY == -1) || (dlPtr->y == dlPtr->oldY) - || ((dlPtr->oldY + dlPtr->height) > dInfoPtr->maxY)) { + /* + * These tests are, in order: + * + * 1. If the line is already marked as invalid + * 2. If the line hasn't moved + * 3. If the line overlaps the bottom of the window and we + * are scrolling up + * 4. If the line overlaps the top of the window and we are + * scrolling down + * + * If any of these tests are true, then we can't scroll this + * line's part of the display. + * + * Note that even if tests 3 or 4 aren't true, we may be + * able to scroll the line, but we still need to be sure + * to call embedded window display procs on top and bottom + * lines if they have any portion non-visible (see below). + */ + if ((dlPtr->flags & OLD_Y_INVALID) + || (dlPtr->y == dlPtr->oldY) + || (((dlPtr->oldY + dlPtr->height) > dInfoPtr->maxY) + && (dlPtr->y < dlPtr->oldY)) + || ((dlPtr->oldY < dInfoPtr->y) + && (dlPtr->y > dlPtr->oldY))) { continue; } @@ -2286,7 +3258,7 @@ DisplayText(clientData) y = dlPtr->y; for (dlPtr2 = dlPtr->nextPtr; dlPtr2 != NULL; dlPtr2 = dlPtr2->nextPtr) { - if ((dlPtr2->oldY == -1) + if ((dlPtr2->flags & OLD_Y_INVALID) || ((dlPtr2->oldY + offset) != dlPtr2->y) || ((dlPtr2->oldY + dlPtr2->height) > dInfoPtr->maxY)) { break; @@ -2298,18 +3270,29 @@ DisplayText(clientData) * Reduce the height of the area being copied if necessary to * avoid overwriting the border area. */ - if ((y + height) > dInfoPtr->maxY) { height = dInfoPtr->maxY -y; } oldY = dlPtr->oldY; - + if (y < dInfoPtr->y) { + /* + * Adjust if the area being copied is going to overwrite + * the top border of the window (so the top line is only + * half onscreen). + */ + int y_off = dInfoPtr->y - dlPtr->y; + height -= y_off; + oldY += y_off; + y = dInfoPtr->y; + } + /* * Update the lines we are going to scroll to show that they * have been copied. */ while (1) { + /* The DLine already has OLD_Y_INVALID cleared */ dlPtr->oldY = dlPtr->y; if (dlPtr->nextPtr == dlPtr2) { break; @@ -2324,10 +3307,10 @@ DisplayText(clientData) */ for ( ; dlPtr2 != NULL; dlPtr2 = dlPtr2->nextPtr) { - if ((dlPtr2->oldY != -1) + if ((!(dlPtr2->flags & OLD_Y_INVALID)) && ((dlPtr2->oldY + dlPtr2->height) > y) && (dlPtr2->oldY < (y + height))) { - dlPtr2->oldY = -1; + dlPtr2->flags |= OLD_Y_INVALID; } } @@ -2439,14 +3422,23 @@ DisplayText(clientData) maxHeight = -1; for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL; dlPtr = dlPtr->nextPtr) { - if ((dlPtr->height > maxHeight) && (dlPtr->oldY != dlPtr->y)) { + if ((dlPtr->height > maxHeight) + && ((dlPtr->flags & OLD_Y_INVALID) || (dlPtr->oldY != dlPtr->y))) { maxHeight = dlPtr->height; } bottomY = dlPtr->y + dlPtr->height; } - if (maxHeight > dInfoPtr->maxY) { - maxHeight = dInfoPtr->maxY; + /* + * There used to be a line here which restricted 'maxHeight' to be no + * larger than 'dInfoPtr->maxY', but this is incorrect for the case + * where individual lines may be taller than the widget _and_ we have + * smooth scrolling. What we can do is restrict maxHeight to be + * no larger than 'dInfoPtr->maxY + dInfoPtr->topPixelOffset'. + */ + if (maxHeight > (dInfoPtr->maxY + dInfoPtr->topPixelOffset)) { + maxHeight = (dInfoPtr->maxY + dInfoPtr->topPixelOffset); } + if (maxHeight > 0) { pixmap = Tk_GetPixmap(Tk_Display(textPtr->tkwin), Tk_WindowId(textPtr->tkwin), Tk_Width(textPtr->tkwin), @@ -2455,7 +3447,7 @@ DisplayText(clientData) (dlPtr != NULL) && (dlPtr->y < dInfoPtr->maxY); prevPtr = dlPtr, dlPtr = dlPtr->nextPtr) { if (dlPtr->chunkPtr == NULL) continue; - if (dlPtr->oldY != dlPtr->y) { + if ((dlPtr->flags & OLD_Y_INVALID) || dlPtr->oldY != dlPtr->y) { if (tkTextDebug) { char string[TK_POS_CHARS]; TkTextPrintIndex(&dlPtr->index, string); @@ -2469,9 +3461,53 @@ DisplayText(clientData) return; } dlPtr->oldY = dlPtr->y; - dlPtr->flags &= ~NEW_LAYOUT; + dlPtr->flags &= ~(NEW_LAYOUT | OLD_Y_INVALID); + } else if (dlPtr->chunkPtr != NULL && ((dlPtr->y < 0) + || (dlPtr->y + dlPtr->height > dInfoPtr->maxY))) { + register TkTextDispChunk *chunkPtr; + + /* + * It's the first or last DLine which are also + * overlapping the top or bottom of the window, but we + * decided above it wasn't necessary to display them (we + * were able to update them by scrolling). This is fine, + * except that if the lines contain any embedded windows, + * we must still call the display proc on them because + * they might need to be unmapped or they might need to + * be moved to reflect their new position. Otherwise, + * everything else moves, but the embedded window + * doesn't! + * + * So, we loop through all the chunks, calling the + * display proc of embedded windows only. + */ + for (chunkPtr = dlPtr->chunkPtr; (chunkPtr != NULL); + chunkPtr = chunkPtr->nextPtr) { + int x; + if (chunkPtr->displayProc != TkTextEmbWinDisplayProc) { + continue; + } + x = chunkPtr->x + dInfoPtr->x - dInfoPtr->curXPixelOffset; + if ((x + chunkPtr->width <= 0) || (x >= dInfoPtr->maxX)) { + /* + * Note: we have to call the displayProc even for + * chunks that are off-screen. This is needed, + * for example, so that embedded windows can be + * unmapped in this case. Display the chunk at a + * coordinate that can be clearly identified by + * the displayProc as being off-screen to the + * left (the displayProc may not be able to tell + * if something is off to the right). + */ + x = -chunkPtr->width; + } + TkTextEmbWinDisplayProc(chunkPtr, x, dlPtr->spaceAbove, + dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow, + dlPtr->baseline - dlPtr->spaceAbove, (Display *) NULL, + (Drawable) None, dlPtr->y + dlPtr->spaceAbove); + } + } - /*prevPtr = dlPtr;*/ } Tk_FreePixmap(Tk_Display(textPtr->tkwin), pixmap); } @@ -2658,9 +3694,11 @@ TextInvalidateRegion(textPtr, region) maxY = rect.y + rect.height; for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL; dlPtr = dlPtr->nextPtr) { - if ((dlPtr->oldY != -1) && (TkRectInRegion(region, rect.x, dlPtr->y, - rect.width, (unsigned int) dlPtr->height) != RectangleOut)) { - dlPtr->oldY = -1; + if ((!(dlPtr->flags & OLD_Y_INVALID)) + && (TkRectInRegion(region, rect.x, dlPtr->y, + rect.width, (unsigned int) dlPtr->height) + != RectangleOut)) { + dlPtr->flags |= OLD_Y_INVALID; } } if (dInfoPtr->topOfEof < maxY) { @@ -2693,6 +3731,10 @@ TextInvalidateRegion(textPtr, region) * changed). This procedure must be called *before* a change is * made, so that indexes in the display information are still * valid. + * + * Note: if the range of indices may change geometry as well + * as simply requiring redisplay, then the caller should also + * call TkTextInvalidateLineMetrics. * * Results: * None. @@ -2707,10 +3749,11 @@ TextInvalidateRegion(textPtr, region) void TkTextChanged(textPtr, index1Ptr, index2Ptr) - TkText *textPtr; /* Widget record for text widget. */ - TkTextIndex *index1Ptr; /* Index of first character to redisplay. */ - TkTextIndex *index2Ptr; /* Index of character just after last one - * to redisplay. */ + TkText *textPtr; /* Widget record for text widget. */ + CONST TkTextIndex *index1Ptr; /* Index of first character to + * redisplay. */ + CONST TkTextIndex *index2Ptr; /* Index of character just after last one + * to redisplay. */ { TextDInfo *dInfoPtr = textPtr->dInfoPtr; DLine *firstPtr, *lastPtr; @@ -2763,7 +3806,7 @@ TkTextChanged(textPtr, index1Ptr, index2Ptr) * Delete all the DLines from firstPtr up to but not including lastPtr. */ - FreeDLines(textPtr, firstPtr, lastPtr, 1); + FreeDLines(textPtr, firstPtr, lastPtr, DLINE_UNLINK); } /* @@ -2806,6 +3849,31 @@ TkTextRedrawTag(textPtr, index1Ptr, index2Ptr, tagPtr, withTag) TkTextIndex *curIndexPtr; TkTextIndex endOfText, *endIndexPtr; + /* + * Invalidate the pixel calculation of all lines in the given range. + * This may be a bit over-aggressive, so we could consider more + * subtle techniques here in the future. In particular, when we + * create a tag for the first time with '.t tag configure foo -font + * "Arial 20"', say, even though that obviously can't apply to + * anything at all (the tag didn't exist a moment ago), we invalidate + * every single line in the widget. + */ + if (tagPtr->affectsDisplayGeometry) { + TkTextLine *startLine, *endLine; + if (index1Ptr == NULL) { + startLine = NULL; + } else { + startLine = index1Ptr->linePtr; + } + if (index2Ptr == NULL) { + endLine = NULL; + } else { + endLine = index2Ptr->linePtr; + } + TkTextInvalidateLineMetrics(textPtr, startLine, endLine - startLine, + TK_TEXT_INVALIDATE_ONLY); + } + /* * Round up the starting position if it's before the first line * visible on the screen (we only care about what's on the screen). @@ -2912,7 +3980,7 @@ TkTextRedrawTag(textPtr, index1Ptr, index2Ptr, tagPtr, withTag) * be re-layed out and redrawn. */ - FreeDLines(textPtr, dlPtr, endPtr, 1); + FreeDLines(textPtr, dlPtr, endPtr, DLINE_UNLINK); dlPtr = endPtr; /* @@ -2947,8 +4015,10 @@ TkTextRedrawTag(textPtr, index1Ptr, index2Ptr, tagPtr, withTag) */ void -TkTextRelayoutWindow(textPtr) +TkTextRelayoutWindow(textPtr, mask) TkText *textPtr; /* Widget record for text widget. */ + int mask; /* OR'd collection of bits showing what + * has changed */ { TextDInfo *dInfoPtr = textPtr->dInfoPtr; GC new; @@ -2981,7 +4051,7 @@ TkTextRelayoutWindow(textPtr) * Throw away all the current layout information. */ - FreeDLines(textPtr, dInfoPtr->dLinePtr, (DLine *) NULL, 1); + FreeDLines(textPtr, dInfoPtr->dLinePtr, (DLine *) NULL, DLINE_UNLINK); dInfoPtr->dLinePtr = NULL; /* @@ -3016,7 +4086,7 @@ TkTextRelayoutWindow(textPtr) */ if (textPtr->topIndex.byteIndex != 0) { - MeasureUp(textPtr, &textPtr->topIndex, 0, &textPtr->topIndex); + TkTextFindDisplayLineEnd(textPtr, &textPtr->topIndex, 0, NULL); } /* @@ -3026,6 +4096,25 @@ TkTextRelayoutWindow(textPtr) dInfoPtr->xScrollFirst = dInfoPtr->xScrollLast = -1; dInfoPtr->yScrollFirst = dInfoPtr->yScrollLast = -1; + + if (mask & TK_TEXT_LINE_GEOMETRY) { + /* + * Set up line metric recalculation. + * + * Avoid the special zero value, since that is used to + * mark individual lines as being out of date. + */ + if ((++dInfoPtr->lineMetricUpdateEpoch) == 0) { + dInfoPtr->lineMetricUpdateEpoch++; + } + dInfoPtr->currentMetricUpdateLine = -1; + + if (dInfoPtr->lineUpdateTimer == NULL) { + textPtr->refCount++; + dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(1, + TkTextAsyncUpdateLineMetrics, (ClientData) textPtr); + } + } } /* @@ -3052,17 +4141,27 @@ TkTextSetYView(textPtr, indexPtr, pickPlace) TkText *textPtr; /* Widget record for text widget. */ TkTextIndex *indexPtr; /* Position that is to appear somewhere * in the view. */ - int pickPlace; /* 0 means topLine must appear at top of - * screen. 1 means we get to pick where it - * appears: minimize screen motion or else - * display line at center of screen. */ + int pickPlace; /* 0 means the given index must appear + * exactly at the top of the screen. + * TK_TEXT_PICKPLACE (-1) means we get to + * pick where it appears: minimize screen + * motion or else display line at center + * of screen. TK_TEXT_NOPIXELADJUST (-2) + * indicates to make the given index the + * top line, but if it is already the top + * line, don't nudge it up or down by a + * few pixels just to make sure it is + * entirely displayed. Positive numbers + * indicate the number of pixels of the + * index's line which are to be off the + * top of the screen. */ { TextDInfo *dInfoPtr = textPtr->dInfoPtr; register DLine *dlPtr; int bottomY, close, lineIndex; TkTextIndex tmpIndex, rounded; - Tk_FontMetrics fm; - + int lineHeight; + /* * If the specified position is the extra line at the end of the * text, round it back to the last real line. @@ -3070,11 +4169,20 @@ TkTextSetYView(textPtr, indexPtr, pickPlace) lineIndex = TkBTreeLineIndex(indexPtr->linePtr); if (lineIndex == TkBTreeNumLines(indexPtr->tree)) { - TkTextIndexBackChars(indexPtr, 1, &rounded); + TkTextIndexBackChars(indexPtr, 1, &rounded, COUNT_INDICES); indexPtr = &rounded; } - if (!pickPlace) { + if (pickPlace == -2) { + if (textPtr->topIndex.linePtr == indexPtr->linePtr + && textPtr->topIndex.byteIndex == indexPtr->byteIndex) { + pickPlace = dInfoPtr->topPixelOffset; + } else { + pickPlace = 0; + } + } + + if (pickPlace != -1) { /* * The specified position must go at the top of the screen. * Just leave all the DLine's alone: we may be able to reuse @@ -3082,11 +4190,11 @@ TkTextSetYView(textPtr, indexPtr, pickPlace) * without redisplaying it all. */ - if (indexPtr->byteIndex == 0) { - textPtr->topIndex = *indexPtr; - } else { - MeasureUp(textPtr, indexPtr, 0, &textPtr->topIndex); + textPtr->topIndex = *indexPtr; + if (indexPtr->byteIndex != 0) { + TkTextFindDisplayLineEnd(textPtr, &textPtr->topIndex, 0, NULL); } + dInfoPtr->newTopPixelOffset = pickPlace; goto scheduleUpdate; } @@ -3111,6 +4219,16 @@ TkTextSetYView(textPtr, indexPtr, pickPlace) dlPtr = NULL; } else if ((dlPtr->index.linePtr == indexPtr->linePtr) && (dlPtr->index.byteIndex <= indexPtr->byteIndex)) { + if (dInfoPtr->dLinePtr == dlPtr + && dInfoPtr->topPixelOffset != 0) { + /* + * It is on the top line, but that line is hanging + * off the top of the screen. Change the top + * overlap to zero and update. + */ + dInfoPtr->newTopPixelOffset = 0; + goto scheduleUpdate; + } return; } } @@ -3119,37 +4237,50 @@ TkTextSetYView(textPtr, indexPtr, pickPlace) * The desired line isn't already on-screen. Figure out what * it means to be "close" to the top or bottom of the screen. * Close means within 1/3 of the screen height or within three - * lines, whichever is greater. Add one extra line also, to - * account for the way MeasureUp rounds. + * lines, whichever is greater. + * + * If the line is not close, place it in the center of the + * window. */ - Tk_GetFontMetrics(textPtr->tkfont, &fm); - bottomY = (dInfoPtr->y + dInfoPtr->maxY + fm.linespace)/2; + lineHeight = TextCalculateDisplayLineHeight(textPtr, indexPtr, NULL); + /* + * It would be better if 'bottomY' were calculated using the + * actual height of the given line, not 'textPtr->charHeight'. + */ + bottomY = (dInfoPtr->y + dInfoPtr->maxY + lineHeight)/2; close = (dInfoPtr->maxY - dInfoPtr->y)/3; - if (close < 3*fm.linespace) { - close = 3*fm.linespace; + if (close < 3*textPtr->charHeight) { + close = 3*textPtr->charHeight; } - close += fm.linespace; if (dlPtr != NULL) { + int overlap; /* * The desired line is above the top of screen. If it is * "close" to the top of the window then make it the top - * line on the screen. + * line on the screen. MeasureUp counts from the bottom + * of the given index upwards, so we add an extra half line + * to be sure we count far enough. */ - MeasureUp(textPtr, &textPtr->topIndex, close, &tmpIndex); + MeasureUp(textPtr, &textPtr->topIndex, close + textPtr->charHeight/2, + &tmpIndex, &overlap); if (TkTextIndexCmp(&tmpIndex, indexPtr) <= 0) { - MeasureUp(textPtr, indexPtr, 0, &textPtr->topIndex); + textPtr->topIndex = *indexPtr; + TkTextFindDisplayLineEnd(textPtr, &textPtr->topIndex, 0, NULL); + dInfoPtr->newTopPixelOffset = 0; goto scheduleUpdate; } } else { + int overlap; /* * The desired line is below the bottom of the screen. If it is * "close" to the bottom of the screen then position it at the * bottom of the screen. */ - MeasureUp(textPtr, indexPtr, close, &tmpIndex); + MeasureUp(textPtr, indexPtr, close + lineHeight + - textPtr->charHeight/2, &tmpIndex, &overlap); if (FindDLine(dInfoPtr->dLinePtr, &tmpIndex) != NULL) { bottomY = dInfoPtr->maxY - dInfoPtr->y; } @@ -3163,7 +4294,8 @@ TkTextSetYView(textPtr, indexPtr, pickPlace) * is a half-line lower than the center of the window. */ - MeasureUp(textPtr, indexPtr, bottomY, &textPtr->topIndex); + MeasureUp(textPtr, indexPtr, bottomY, &textPtr->topIndex, + &dInfoPtr->newTopPixelOffset); scheduleUpdate: if (!(dInfoPtr->flags & REDRAW_PENDING)) { @@ -3175,11 +4307,72 @@ TkTextSetYView(textPtr, indexPtr, pickPlace) /* *-------------------------------------------------------------- * - * MeasureUp -- + * TkTextMeasureDown -- * * Given one index, find the index of the first character * on the highest display line that would be displayed no more - * than "distance" pixels above the given index. + * than "distance" pixels below the top of the given index. + * + * Results: + * The srcPtr is manipulated in place to reflect the new + * position. We return the number of pixels by which 'distance' + * overlaps the srcPtr. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + +int +TkTextMeasureDown(textPtr, srcPtr, distance) + TkText *textPtr; /* Text widget in which to measure. */ + TkTextIndex *srcPtr; /* Index of character from which to start + * measuring. */ + int distance; /* Vertical distance in pixels measured + * from the top pixel in srcPtr's + logical line. */ +{ + TkTextLine *lastLinePtr; + DLine *dlPtr; + TkTextIndex loop; + + lastLinePtr = TkBTreeFindLine(textPtr->tree, + TkBTreeNumLines(textPtr->tree)); + + do { + dlPtr = LayoutDLine(textPtr, srcPtr); + dlPtr->nextPtr = NULL; + + if (distance < dlPtr->height) { + FreeDLines(textPtr, dlPtr, (DLine *) NULL, DLINE_FREE_TEMP); + break; + } + distance -= dlPtr->height; + TkTextIndexForwBytes(srcPtr, dlPtr->byteCount, &loop); + FreeDLines(textPtr, dlPtr, (DLine *) NULL, DLINE_FREE_TEMP); + if (loop.linePtr == lastLinePtr) { + break; + } + *srcPtr = loop; + } while (distance > 0); + + return distance; +} + +/* + *-------------------------------------------------------------- + * + * MeasureUp -- + * + * Given one index, find the index of the first character on the + * highest display line that would be displayed no more than + * "distance" pixels above the given index. + * + * If this function is called with distance=0, it simply finds the + * first index on the same display line as srcPtr. However, there + * is a another function TkTextFindDisplayLineEnd designed just for + * that task which is probably better to use. * * Results: * *dstPtr is filled in with the index of the first character @@ -3187,9 +4380,8 @@ TkTextSetYView(textPtr, indexPtr, pickPlace) * up "distance" pixels above the pixel just below an imaginary * display line that contains srcPtr. If the display line * that covers this coordinate actually extends above the - * coordinate, then return the index of the next lower line - * instead (i.e. the returned index will be completely visible - * at or below the given y-coordinate). + * coordinate, then return any excess pixels in *overlap, if + * that is non-NULL. * * Side effects: * None. @@ -3198,30 +4390,31 @@ TkTextSetYView(textPtr, indexPtr, pickPlace) */ static void -MeasureUp(textPtr, srcPtr, distance, dstPtr) +MeasureUp(textPtr, srcPtr, distance, dstPtr, overlap) TkText *textPtr; /* Text widget in which to measure. */ - TkTextIndex *srcPtr; /* Index of character from which to start + CONST TkTextIndex *srcPtr; /* Index of character from which to start * measuring. */ int distance; /* Vertical distance in pixels measured * from the pixel just below the lowest * one in srcPtr's line. */ TkTextIndex *dstPtr; /* Index to fill in with result. */ + int *overlap; /* Used to store how much of the final + * index returned was not covered by + * 'distance'. */ { int lineNum; /* Number of current line. */ int bytesToCount; /* Maximum number of bytes to measure in * current line. */ - TkTextIndex bestIndex; /* Best candidate seen so far for result. */ TkTextIndex index; DLine *dlPtr, *lowestPtr; - int noBestYet; /* 1 means bestIndex hasn't been set. */ - noBestYet = 1; bytesToCount = srcPtr->byteIndex + 1; index.tree = srcPtr->tree; for (lineNum = TkBTreeLineIndex(srcPtr->linePtr); lineNum >= 0; lineNum--) { /* * Layout an entire text line (potentially > 1 display line). + * * For the first line, which contains srcPtr, only layout the * part up through srcPtr (bytesToCount is non-infinite to * accomplish this). Make a list of all the display lines @@ -3243,17 +4436,20 @@ MeasureUp(textPtr, srcPtr, distance, dstPtr) /* * Scan through the display lines to see if we've covered enough * vertical distance. If so, save the starting index for the - * line at the desired location. + * line at the desired location. If distance was zero to start + * with then we simply get the first index on the same display + * line as the original index. */ for (dlPtr = lowestPtr; dlPtr != NULL; dlPtr = dlPtr->nextPtr) { distance -= dlPtr->height; - if (distance < 0) { - *dstPtr = (noBestYet) ? dlPtr->index : bestIndex; + if (distance <= 0) { + *dstPtr = dlPtr->index; + if (overlap != NULL) { + *overlap = -distance; + } break; } - bestIndex = dlPtr->index; - noBestYet = 0; } /* @@ -3261,8 +4457,8 @@ MeasureUp(textPtr, srcPtr, distance, dstPtr) * for the next display line to lay out. */ - FreeDLines(textPtr, lowestPtr, (DLine *) NULL, 0); - if (distance < 0) { + FreeDLines(textPtr, lowestPtr, (DLine *) NULL, DLINE_FREE); + if (distance <= 0) { return; } bytesToCount = INT_MAX; /* Consider all chars. in next line. */ @@ -3274,6 +4470,9 @@ MeasureUp(textPtr, srcPtr, distance, dstPtr) */ TkTextMakeByteIndex(textPtr->tree, 0, 0, dstPtr); + if (overlap != NULL) { + *overlap = 0; + } } /* @@ -3310,8 +4509,7 @@ TkTextSeeCmd(textPtr, interp, objc, objv) TkTextDispChunk *chunkPtr; if (objc != 3) { - Tcl_AppendResult(interp, "wrong # args: should be \"", - Tcl_GetString(objv[0]), " see index\"", (char *) NULL); + Tcl_WrongNumArgs(interp, 2, objv, "index"); return TCL_ERROR; } if (TkTextGetObjIndex(interp, textPtr, objv[2], &index) != TCL_OK) { @@ -3324,14 +4522,14 @@ TkTextSeeCmd(textPtr, interp, objc, objv) */ if (TkBTreeLineIndex(index.linePtr) == TkBTreeNumLines(index.tree)) { - TkTextIndexBackChars(&index, 1, &index); + TkTextIndexBackChars(&index, 1, &index, COUNT_INDICES); } /* * First get the desired position into the vertical range of the window. */ - TkTextSetYView(textPtr, &index, 1); + TkTextSetYView(textPtr, &index, TK_TEXT_PICKPLACE); /* * Now make sure that the character is in view horizontally. @@ -3376,24 +4574,24 @@ TkTextSeeCmd(textPtr, interp, objc, objv) dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow, dlPtr->baseline - dlPtr->spaceAbove, &x, &y, &width, &height); - delta = x - dInfoPtr->curPixelOffset; + delta = x - dInfoPtr->curXPixelOffset; oneThird = lineWidth/3; if (delta < 0) { if (delta < -oneThird) { - dInfoPtr->newByteOffset = (x - lineWidth/2) + dInfoPtr->newXByteOffset = (x - lineWidth/2) / textPtr->charWidth; } else { - dInfoPtr->newByteOffset -= ((-delta) + textPtr->charWidth - 1) + dInfoPtr->newXByteOffset -= ((-delta) + textPtr->charWidth - 1) / textPtr->charWidth; } } else { delta -= (lineWidth - width); if (delta > 0) { if (delta > oneThird) { - dInfoPtr->newByteOffset = (x - lineWidth/2) + dInfoPtr->newXByteOffset = (x - lineWidth/2) / textPtr->charWidth; } else { - dInfoPtr->newByteOffset += (delta + textPtr->charWidth - 1) + dInfoPtr->newXByteOffset += (delta + textPtr->charWidth - 1) / textPtr->charWidth; } } else { @@ -3449,7 +4647,7 @@ TkTextXviewCmd(textPtr, interp, objc, objv) return TCL_OK; } - newOffset = dInfoPtr->newByteOffset; + newOffset = dInfoPtr->newXByteOffset; type = Tk_GetScrollInfoObj(interp, objc, objv, &fraction, &count); switch (type) { case TK_SCROLL_ERROR: @@ -3461,8 +4659,8 @@ TkTextXviewCmd(textPtr, interp, objc, objv) if (fraction < 0) { fraction = 0; } - newOffset = (int) (((fraction * dInfoPtr->maxLength) / textPtr->charWidth) - + 0.5); + newOffset = (int) (((fraction * dInfoPtr->maxLength) + / textPtr->charWidth) + 0.5); break; case TK_SCROLL_PAGES: charsPerPage = ((dInfoPtr->maxX - dInfoPtr->x) / textPtr->charWidth) @@ -3477,7 +4675,7 @@ TkTextXviewCmd(textPtr, interp, objc, objv) break; } - dInfoPtr->newByteOffset = newOffset; + dInfoPtr->newXByteOffset = newOffset; dInfoPtr->flags |= DINFO_OUT_OF_DATE; if (!(dInfoPtr->flags & REDRAW_PENDING)) { dInfoPtr->flags |= REDRAW_PENDING; @@ -3489,7 +4687,87 @@ TkTextXviewCmd(textPtr, interp, objc, objv) /* *---------------------------------------------------------------------- * - * ScrollByLines -- + * YScrollByPixels -- + * + * This procedure is called to scroll a text widget up or down + * by a given number of pixels. + * + * Results: + * None. + * + * Side effects: + * The view in textPtr's window changes to reflect the value + * of "offset". + * + *---------------------------------------------------------------------- + */ + +static void +YScrollByPixels(textPtr, offset) + TkText *textPtr; /* Widget to scroll. */ + int offset; /* Amount by which to scroll, in + * pixels. Positive means that information + * later in text becomes visible, negative + * means that information earlier in the + * text becomes visible. */ +{ + TextDInfo *dInfoPtr = textPtr->dInfoPtr; + + if (offset < 0) { + /* + * Now we want to measure up this number of pixels + * from the top of the screen. But the top line may + * not be totally visible. Note that 'count' is + * negative here. + */ + offset -= TextCalculateDisplayLineHeight(textPtr, + &textPtr->topIndex, NULL) - dInfoPtr->topPixelOffset; + MeasureUp(textPtr, &textPtr->topIndex, -offset, + &textPtr->topIndex, &dInfoPtr->newTopPixelOffset); + } else if (offset > 0) { + DLine *dlPtr; + TkTextLine *lastLinePtr; + TkTextIndex new; + /* + * Scrolling down by pixels. Layout lines starting at + * the top index and count through the desired vertical + * distance. + */ + + lastLinePtr = TkBTreeFindLine(textPtr->tree, + TkBTreeNumLines(textPtr->tree)); + offset += dInfoPtr->topPixelOffset; + dInfoPtr->newTopPixelOffset = 0; + while (offset > 0) { + dlPtr = LayoutDLine(textPtr, &textPtr->topIndex); + dlPtr->nextPtr = NULL; + TkTextIndexForwBytes(&textPtr->topIndex, dlPtr->byteCount, + &new); + if (offset <= dlPtr->height) { + /* Adjust the top overlap accordingly */ + dInfoPtr->newTopPixelOffset = offset; + } + offset -= dlPtr->height; + FreeDLines(textPtr, dlPtr, (DLine *) NULL, DLINE_FREE_TEMP); + if (new.linePtr == lastLinePtr || offset <= 0) { + break; + } + textPtr->topIndex = new; + } + } else { + /* offset = 0, so no scrolling required */ + return; + } + if (!(dInfoPtr->flags & REDRAW_PENDING)) { + Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr); + } + dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED; +} + +/* + *---------------------------------------------------------------------- + * + * YScrollByLines -- * * This procedure is called to scroll a text widget up or down * by a given number of lines. @@ -3505,9 +4783,9 @@ TkTextXviewCmd(textPtr, interp, objc, objv) */ static void -ScrollByLines(textPtr, offset) +YScrollByLines(textPtr, offset) TkText *textPtr; /* Widget to scroll. */ - int offset; /* Amount by which to scroll, in *screen* + int offset; /* Amount by which to scroll, in display * lines. Positive means that information * later in text becomes visible, negative * means that information earlier in the @@ -3556,7 +4834,7 @@ ScrollByLines(textPtr, offset) * for the next display line to lay out. */ - FreeDLines(textPtr, lowestPtr, (DLine *) NULL, 0); + FreeDLines(textPtr, lowestPtr, (DLine *) NULL, DLINE_FREE); if (offset >= 0) { goto scheduleUpdate; } @@ -3565,10 +4843,12 @@ ScrollByLines(textPtr, offset) /* * Ran off the beginning of the text. Return the first character - * in the text. + * in the text, and make sure we haven't left anything + * overlapping the top window border. */ TkTextMakeByteIndex(textPtr->tree, 0, 0, &textPtr->topIndex); + dInfoPtr->newTopPixelOffset = 0; } else { /* * Scrolling down, to show later information in the text. @@ -3582,7 +4862,7 @@ ScrollByLines(textPtr, offset) if (dlPtr->length == 0 && dlPtr->height == 0) offset++; dlPtr->nextPtr = NULL; TkTextIndexForwBytes(&textPtr->topIndex, dlPtr->byteCount, &new); - FreeDLines(textPtr, dlPtr, (DLine *) NULL, 0); + FreeDLines(textPtr, dlPtr, (DLine *) NULL, DLINE_FREE); if (new.linePtr == lastLinePtr) { break; } @@ -3625,14 +4905,11 @@ TkTextYviewCmd(textPtr, interp, objc, objv) * objv[1] is "yview". */ { TextDInfo *dInfoPtr = textPtr->dInfoPtr; - int pickPlace, lineNum, type, bytesInLine; - Tk_FontMetrics fm; + int pickPlace, type; int pixels, count; size_t switchLength; double fraction; - TkTextIndex index, new; - TkTextLine *lastLinePtr; - DLine *dlPtr; + TkTextIndex index; if (dInfoPtr->flags & DINFO_OUT_OF_DATE) { UpdateDisplayInfo(textPtr); @@ -3651,18 +4928,17 @@ TkTextYviewCmd(textPtr, interp, objc, objv) if (Tcl_GetString(objv[2])[0] == '-') { switchLength = strlen(Tcl_GetString(objv[2])); if ((switchLength >= 2) - && (strncmp(Tcl_GetString(objv[2]), "-pickplace", switchLength) == 0)) { + && (strncmp(Tcl_GetString(objv[2]), + "-pickplace", switchLength) == 0)) { pickPlace = 1; if (objc != 4) { - Tcl_AppendResult(interp, "wrong # args: should be \"", - Tcl_GetString(objv[0]), - " yview -pickplace lineNum|index\"", - (char *) NULL); + Tcl_WrongNumArgs(interp, 3, objv, "lineNum|index"); return TCL_ERROR; } } } if ((objc == 3) || pickPlace) { + int lineNum; if (Tcl_GetIntFromObj(interp, objv[2+pickPlace], &lineNum) == TCL_OK) { TkTextMakeByteIndex(textPtr->tree, lineNum, 0, &index); TkTextSetYView(textPtr, &index, 0); @@ -3678,7 +4954,7 @@ TkTextYviewCmd(textPtr, interp, objc, objv) &index) != TCL_OK) { return TCL_ERROR; } - TkTextSetYView(textPtr, &index, pickPlace); + TkTextSetYView(textPtr, &index, (pickPlace ? TK_TEXT_PICKPLACE : 0)); return TCL_OK; } @@ -3686,79 +4962,67 @@ TkTextYviewCmd(textPtr, interp, objc, objv) * New syntax: dispatch based on objv[2]. */ - type = Tk_GetScrollInfoObj(interp, objc, objv, &fraction, &count); + type = TextGetScrollInfoObj(interp, textPtr, objc, objv, + &fraction, &count); switch (type) { - case TK_SCROLL_ERROR: + case TKTEXT_SCROLL_ERROR: return TCL_ERROR; - case TK_SCROLL_MOVETO: + case TKTEXT_SCROLL_MOVETO: if (fraction > 1.0) { fraction = 1.0; } if (fraction < 0) { fraction = 0; } - fraction *= TkBTreeNumLines(textPtr->tree); - lineNum = (int) fraction; - TkTextMakeByteIndex(textPtr->tree, lineNum, 0, &index); - bytesInLine = TkBTreeBytesInLine(index.linePtr); - index.byteIndex = (int)((bytesInLine * (fraction-lineNum)) + 0.5); - if (index.byteIndex >= bytesInLine) { - TkTextMakeByteIndex(textPtr->tree, lineNum + 1, 0, &index); - } - TkTextSetYView(textPtr, &index, 0); + fraction *= (TkBTreeNumPixels(textPtr->tree)-1); + /* + * This function returns the number of pixels by which the + * given line should overlap the top of the visible screen. + * + * This is then used to provide smooth scrolling. + */ + pixels = TkTextMakePixelIndex(textPtr, (int) (0.5 + fraction), + &index); + TkTextSetYView(textPtr, &index, pixels); break; - case TK_SCROLL_PAGES: + case TKTEXT_SCROLL_PAGES: { /* * Scroll up or down by screenfuls. Actually, use the * window height minus two lines, so that there's some * overlap between adjacent pages. */ - - Tk_GetFontMetrics(textPtr->tkfont, &fm); - if (count < 0) { - pixels = (dInfoPtr->maxY - 2*fm.linespace - dInfoPtr->y)*(-count) - + fm.linespace; - MeasureUp(textPtr, &textPtr->topIndex, pixels, &new); - if (TkTextIndexCmp(&textPtr->topIndex, &new) == 0) { - /* - * A page of scrolling ended up being less than one line. - * Scroll one line anyway. + int height = dInfoPtr->maxY - dInfoPtr->y; + if (textPtr->charHeight * 4 >= height) { + /* + * A single line is more than a quarter of the + * display. We choose to scroll by 3/4 of the + * height instead. + */ + pixels = 3*height/4; + if (pixels < textPtr->charHeight) { + /* + * But, if 3/4 of the height is actually less than a + * single typical character height, then scroll by + * the minimum of the linespace or the total height. */ - - count = -1; - goto scrollByLines; + if (textPtr->charHeight < height) { + pixels = textPtr->charHeight; + } else { + pixels = height; + } } - textPtr->topIndex = new; + pixels *= count; } else { - /* - * Scrolling down by pages. Layout lines starting at the - * top index and count through the desired vertical distance. - */ - - pixels = (dInfoPtr->maxY - 2*fm.linespace - dInfoPtr->y)*count; - lastLinePtr = TkBTreeFindLine(textPtr->tree, - TkBTreeNumLines(textPtr->tree)); - do { - dlPtr = LayoutDLine(textPtr, &textPtr->topIndex); - dlPtr->nextPtr = NULL; - TkTextIndexForwBytes(&textPtr->topIndex, dlPtr->byteCount, - &new); - pixels -= dlPtr->height; - FreeDLines(textPtr, dlPtr, (DLine *) NULL, 0); - if (new.linePtr == lastLinePtr) { - break; - } - textPtr->topIndex = new; - } while (pixels > 0); + pixels = (height - 2*textPtr->charHeight)*count; } - if (!(dInfoPtr->flags & REDRAW_PENDING)) { - Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr); - } - dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED; + YScrollByPixels(textPtr, pixels); break; - case TK_SCROLL_UNITS: - scrollByLines: - ScrollByLines(textPtr, count); + } + case TKTEXT_SCROLL_PIXELS: + YScrollByPixels(textPtr, count); + break; + case TKTEXT_SCROLL_UNITS: + YScrollByLines(textPtr, count); break; } return TCL_OK; @@ -3794,13 +5058,13 @@ TkTextScanCmd(textPtr, interp, objc, objv) TextDInfo *dInfoPtr = textPtr->dInfoPtr; TkTextIndex index; int c, x, y, totalScroll, newByte, maxByte, gain=10; - Tk_FontMetrics fm; size_t length; if ((objc != 5) && (objc != 6)) { Tcl_AppendResult(interp, "wrong # args: should be \"", Tcl_GetString(objv[0]), " scan mark x y\" or \"", - Tcl_GetString(objv[0]), " scan dragto x y ?gain?\"", (char *) NULL); + Tcl_GetString(objv[0]), " scan dragto x y ?gain?\"", + (char *) NULL); return TCL_ERROR; } if (Tcl_GetIntFromObj(interp, objv[3], &x) != TCL_OK) { @@ -3809,8 +5073,9 @@ TkTextScanCmd(textPtr, interp, objc, objv) if (Tcl_GetIntFromObj(interp, objv[4], &y) != TCL_OK) { return TCL_ERROR; } - if ((objc == 6) && (Tcl_GetIntFromObj(interp, objv[5], &gain) != TCL_OK)) - return TCL_ERROR; + if ((objc == 6) && (Tcl_GetIntFromObj(interp, objv[5], &gain) != TCL_OK)) { + return TCL_ERROR; + } c = Tcl_GetString(objv[2])[0]; length = strlen(Tcl_GetString(objv[2])); if ((c == 'd') && (strncmp(Tcl_GetString(objv[2]), "dragto", length) == 0)) { @@ -3839,24 +5104,24 @@ TkTextScanCmd(textPtr, interp, objc, objv) dInfoPtr->scanMarkIndex = maxByte; dInfoPtr->scanMarkX = x; } - dInfoPtr->newByteOffset = newByte; + dInfoPtr->newXByteOffset = newByte; - Tk_GetFontMetrics(textPtr->tkfont, &fm); - totalScroll = (gain*(dInfoPtr->scanMarkY - y)) / fm.linespace; - if (totalScroll != dInfoPtr->scanTotalScroll) { + totalScroll = gain*(dInfoPtr->scanMarkY - y); + if (totalScroll != dInfoPtr->scanTotalYScroll) { index = textPtr->topIndex; - ScrollByLines(textPtr, totalScroll-dInfoPtr->scanTotalScroll); - dInfoPtr->scanTotalScroll = totalScroll; + YScrollByPixels(textPtr, totalScroll-dInfoPtr->scanTotalYScroll); + dInfoPtr->scanTotalYScroll = totalScroll; if ((index.linePtr == textPtr->topIndex.linePtr) && (index.byteIndex == textPtr->topIndex.byteIndex)) { - dInfoPtr->scanTotalScroll = 0; + dInfoPtr->scanTotalYScroll = 0; dInfoPtr->scanMarkY = y; } } - } else if ((c == 'm') && (strncmp(Tcl_GetString(objv[2]), "mark", length) == 0)) { - dInfoPtr->scanMarkIndex = dInfoPtr->newByteOffset; + } else if ((c == 'm') + && (strncmp(Tcl_GetString(objv[2]), "mark", length) == 0)) { + dInfoPtr->scanMarkIndex = dInfoPtr->newXByteOffset; dInfoPtr->scanMarkX = x; - dInfoPtr->scanTotalScroll = 0; + dInfoPtr->scanTotalYScroll = 0; dInfoPtr->scanMarkY = y; } else { Tcl_AppendResult(interp, "bad scan option \"", Tcl_GetString(objv[2]), @@ -3906,12 +5171,12 @@ GetXView(interp, textPtr, report) * scrollbar if it has changed. */ { TextDInfo *dInfoPtr = textPtr->dInfoPtr; - char buffer[TCL_DOUBLE_SPACE * 2 + 1]; double first, last; int code; - + Tcl_Obj *listObj; + if (dInfoPtr->maxLength > 0) { - first = ((double) dInfoPtr->curPixelOffset) + first = ((double) dInfoPtr->curXPixelOffset) / dInfoPtr->maxLength; last = first + ((double) (dInfoPtr->maxX - dInfoPtr->x)) / dInfoPtr->maxLength; @@ -3923,8 +5188,10 @@ GetXView(interp, textPtr, report) last = 1.0; } if (!report) { - sprintf(buffer, "%g %g", first, last); - Tcl_SetResult(interp, buffer, TCL_VOLATILE); + listObj = Tcl_NewListObj(0,NULL); + Tcl_ListObjAppendElement(interp, listObj, Tcl_NewDoubleObj(first)); + Tcl_ListObjAppendElement(interp, listObj, Tcl_NewDoubleObj(last)); + Tcl_SetObjResult(interp, listObj); return; } if (FP_EQUAL_SCALE(first, dInfoPtr->xScrollFirst, dInfoPtr->maxLength) && @@ -3933,19 +5200,67 @@ GetXView(interp, textPtr, report) } dInfoPtr->xScrollFirst = first; dInfoPtr->xScrollLast = last; - sprintf(buffer, " %g %g", first, last); - code = Tcl_VarEval(interp, textPtr->xScrollCmd, - buffer, (char *) NULL); - if (code != TCL_OK) { - Tcl_AddErrorInfo(interp, + if (textPtr->xScrollCmd != NULL) { + listObj = Tcl_NewStringObj(textPtr->xScrollCmd, -1); + code = Tcl_ListObjAppendElement(interp, listObj, Tcl_NewDoubleObj(first)); + if (code == TCL_OK) { + Tcl_ListObjAppendElement(interp, listObj, Tcl_NewDoubleObj(last)); + code = Tcl_EvalObjEx(interp, listObj, + TCL_EVAL_DIRECT | TCL_EVAL_GLOBAL); + } + if (code != TCL_OK) { + Tcl_AddErrorInfo(interp, "\n (horizontal scrolling command executed by text)"); - Tcl_BackgroundError(interp); + Tcl_BackgroundError(interp); + } } } /* *---------------------------------------------------------------------- * + * GetPixelCount -- + * + * How many pixels are there between the absolute top of the + * widget and the top of the given DLine. + * + * Results: + * The number of pixels. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static int +GetPixelCount(textPtr, dlPtr) + TkText *textPtr; /* Information about text widget. */ + DLine *dlPtr; /* Information about the layout + * of a given index */ +{ + TkTextLine *linePtr = dlPtr->index.linePtr; + /* + * Get the pixel count of one pixel beyond the + * botton of the given line. + */ + int count = TkBTreePixels(linePtr) + linePtr->pixelHeight; + + /* + * Now we have to subtract off the distance between the top of this + * dlPtr and the next logical line. + */ + do { + count -= dlPtr->height; + dlPtr = dlPtr->nextPtr; + } while (dlPtr != NULL && (dlPtr->index.linePtr == linePtr)); + + return count; +} + +/* + *---------------------------------------------------------------------- + * * GetYView -- * * This procedure computes the fractions that indicate what's @@ -3967,7 +5282,7 @@ GetXView(interp, textPtr, report) * *---------------------------------------------------------------------- */ - + static void GetYView(interp, textPtr, report) Tcl_Interp *interp; /* If "report" is FALSE, string @@ -3978,53 +5293,153 @@ GetYView(interp, textPtr, report) * scrollbar if it has changed. */ { TextDInfo *dInfoPtr = textPtr->dInfoPtr; - char buffer[TCL_DOUBLE_SPACE * 2 + 1]; double first, last; DLine *dlPtr; - int totalLines, code, count; - + int totalPixels, code, count; + Tcl_Obj *listObj; + dlPtr = dInfoPtr->dLinePtr; - totalLines = TkBTreeNumLines(textPtr->tree); - first = (double) TkBTreeLineIndex(dlPtr->index.linePtr) - + (double) dlPtr->index.byteIndex - / TkBTreeBytesInLine(dlPtr->index.linePtr); - first /= totalLines; + + if (dlPtr == NULL) { + return; + } + + totalPixels = TkBTreeNumPixels(textPtr->tree); + + /* + * Get the pixel count for the first display visible pixel of the + * first visible line. If the first visible line is only partially + * visible, then we use 'topPixelOffset' to get the difference. + */ + count = GetPixelCount(textPtr, dlPtr); + first = ((double) (count + dInfoPtr->topPixelOffset))/((double)totalPixels); + + /* + * Add on the total number of visible pixels to get the count to + * the last visible pixel. + */ while (1) { - if ((dlPtr->y + dlPtr->height) > dInfoPtr->maxY) { + int extra; + count += dlPtr->height; + + extra = dlPtr->y + dlPtr->height - dInfoPtr->maxY; + if (extra > 0) { /* - * The last line is only partially visible, so don't - * count its characters in what's visible. + * This much of the last line is not visible, so don't + * count these pixels. Since we've reached the bottom + * of the window, we break out of the loop. */ - count = 0; + count -= extra; break; } if (dlPtr->nextPtr == NULL) { - count = dlPtr->byteCount; break; } dlPtr = dlPtr->nextPtr; } - last = ((double) TkBTreeLineIndex(dlPtr->index.linePtr)) - + ((double) (dlPtr->index.byteIndex + count)) - / (TkBTreeBytesInLine(dlPtr->index.linePtr)); - last /= totalLines; + + if (count > totalPixels) { + /* + * It can be possible, if we do not update each line's + * pixelHeight cache when we lay out individual DLines that + * the count generated here is more up-to-date than that + * maintained by the BTree. In such a case, the best we can + * do here is to fix up 'count' and continue, which might + * result in small, temporary perturbations to the size of + * the scrollbar. This is basically harmless, but in a + * perfect world we would not have this problem. + * + * For debugging purposes, if anyone wishes to improve the text + * widget further, the following 'panic' can be activated. In + * principle it should be possible to ensure the BTree is always + * at least as up to date as the display, so in the future we + * might be able to leave the 'panic' in permanently when we + * believe we have resolved the cache synchronisation issue. + * + * However, to achieve that goal would, I think, require a + * fairly substantial refactorisation of the code in this + * file so that there is much more obvious and explicit + * coordination between calls to LayoutDLine and updating + * of each TkTextLine's pixelHeight. The complicated bit + * is that LayoutDLine deals with individual display lines, + * but pixelHeight is for a logical line. + */ +#if 0 + char buffer[200]; + + sprintf(buffer, + "Counted more pixels (%d) than expected (%d) total pixels in text widget scroll bar calculation.", + count, totalPixels); + panic(buffer); +#endif + count = totalPixels; + } + + last = ((double) (count))/((double)totalPixels); + if (!report) { - sprintf(buffer, "%g %g", first, last); - Tcl_SetResult(interp, buffer, TCL_VOLATILE); + listObj = Tcl_NewListObj(0,NULL); + Tcl_ListObjAppendElement(interp, listObj, Tcl_NewDoubleObj(first)); + Tcl_ListObjAppendElement(interp, listObj, Tcl_NewDoubleObj(last)); + Tcl_SetObjResult(interp, listObj); return; } - if (FP_EQUAL_SCALE(first, dInfoPtr->yScrollFirst, totalLines) && - FP_EQUAL_SCALE(last, dInfoPtr->yScrollLast, totalLines)) { + if (FP_EQUAL_SCALE(first, dInfoPtr->yScrollFirst, totalPixels) && + FP_EQUAL_SCALE(last, dInfoPtr->yScrollLast, totalPixels)) { return; } dInfoPtr->yScrollFirst = first; dInfoPtr->yScrollLast = last; - sprintf(buffer, " %g %g", first, last); - code = Tcl_VarEval(interp, textPtr->yScrollCmd, buffer, (char *) NULL); - if (code != TCL_OK) { - Tcl_AddErrorInfo(interp, - "\n (vertical scrolling command executed by text)"); - Tcl_BackgroundError(interp); + if (textPtr->yScrollCmd != NULL) { + listObj = Tcl_NewStringObj(textPtr->yScrollCmd, -1); + code = Tcl_ListObjAppendElement(interp, listObj, + Tcl_NewDoubleObj(first)); + if (code == TCL_OK) { + Tcl_ListObjAppendElement(interp, listObj, Tcl_NewDoubleObj(last)); + code = Tcl_EvalObjEx(interp, listObj, + TCL_EVAL_DIRECT | TCL_EVAL_GLOBAL); + } + if (code != TCL_OK) { + Tcl_AddErrorInfo(interp, + "\n (vertical scrolling command executed by text)"); + Tcl_BackgroundError(interp); + } + } +} + +/* + *---------------------------------------------------------------------- + * + * TkTextUpdateYScrollbar -- + * + * This procedure is called to update the vertical scrollbar + * asychronously as the pixel height calculations progress for + * lines in the widget. + * + * Results: + * None. + * + * Side effects: + * See 'GetYView'. In particular the scrollbar position and size + * may be changed. + * + *---------------------------------------------------------------------- + */ + +void +TkTextUpdateYScrollbar(clientData) + ClientData clientData; /* Information about widget. */ +{ + register TkText *textPtr = (TkText *) clientData; + + textPtr->dInfoPtr->scrollbarTimer = NULL; + + if (!(textPtr->flags & DESTROYED)) { + GetYView(textPtr->interp, textPtr, 1); + } + + if (--textPtr->refCount == 0) { + ckfree((char *) textPtr); } } @@ -4128,8 +5543,7 @@ TkTextPixelIndex(textPtr, x, y, indexPtr) * index of the character nearest to (x,y). */ { TextDInfo *dInfoPtr = textPtr->dInfoPtr; - register DLine *dlPtr, *validdlPtr; - register TkTextDispChunk *chunkPtr; + register DLine *dlPtr, *validDlPtr; /* * Make sure that all of the layout information about what's @@ -4161,9 +5575,10 @@ TkTextPixelIndex(textPtr, x, y, indexPtr) * Find the display line containing the desired y-coordinate. */ - for (dlPtr = validdlPtr = dInfoPtr->dLinePtr; y >= (dlPtr->y + dlPtr->height); - dlPtr = dlPtr->nextPtr) { - if (dlPtr->chunkPtr !=NULL) validdlPtr = dlPtr; + for (dlPtr = validDlPtr = dInfoPtr->dLinePtr; + y >= (dlPtr->y + dlPtr->height); + dlPtr = dlPtr->nextPtr) { + if (dlPtr->chunkPtr !=NULL) validDlPtr = dlPtr; if (dlPtr->nextPtr == NULL) { /* * Y-coordinate is off the bottom of the displayed text. @@ -4174,8 +5589,43 @@ TkTextPixelIndex(textPtr, x, y, indexPtr) break; } } - if (dlPtr->chunkPtr == NULL) dlPtr = validdlPtr; + if (dlPtr->chunkPtr == NULL) dlPtr = validDlPtr; + + DlineIndexOfX(textPtr, dlPtr, x, indexPtr); +} + +/* + *---------------------------------------------------------------------- + * + * DlineIndexOfX -- + * + * Given an x coordinate in a display line, find the index of + * the character closest to that location. + * + * This is effectively the opposite of DlineXOfIndex. + * + * Results: + * The index at *indexPtr is modified to refer to the character + * on the display line that is closest to x. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ +static void +DlineIndexOfX(textPtr, dlPtr, x, indexPtr) + TkText *textPtr; /* Widget record for text widget. */ + DLine *dlPtr; /* Display information for this + * display line. */ + int x; /* Pixel x coordinate of point in widget's + * window. */ + TkTextIndex *indexPtr; /* This index gets filled in with the + * index of the character nearest to x. */ +{ + TextDInfo *dInfoPtr = textPtr->dInfoPtr; + register TkTextDispChunk *chunkPtr; /* * Scan through the line's chunks to find the one that contains @@ -4185,13 +5635,13 @@ TkTextPixelIndex(textPtr, x, y, indexPtr) */ *indexPtr = dlPtr->index; - x = x - dInfoPtr->x + dInfoPtr->curPixelOffset; + x = x - dInfoPtr->x + dInfoPtr->curXPixelOffset; for (chunkPtr = dlPtr->chunkPtr; x >= (chunkPtr->x + chunkPtr->width); indexPtr->byteIndex += chunkPtr->numBytes, chunkPtr = chunkPtr->nextPtr) { if (chunkPtr->nextPtr == NULL) { indexPtr->byteIndex += chunkPtr->numBytes; - TkTextIndexBackChars(indexPtr, 1, indexPtr); + TkTextIndexBackChars(indexPtr, 1, indexPtr, COUNT_INDICES); return; } } @@ -4209,6 +5659,110 @@ TkTextPixelIndex(textPtr, x, y, indexPtr) /* *---------------------------------------------------------------------- * + * TkTextIndexOfX -- + * + * Given a logical x coordinate (i.e. distance in pixels from the + * beginning of the display line, not taking into account any + * information about the window, scrolling etc.) on the display + * line starting with the given index, adjust that index to refer to + * the object under the x coordinate. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkTextIndexOfX(textPtr, x, indexPtr) + TkText *textPtr; /* Widget record for text widget. */ + int x; /* The x coordinate for which we want + * the index */ + TkTextIndex *indexPtr; /* Index of display line start, which + * will be adjusted to the index under the + * given x coordinate. */ +{ + DLine *dlPtr = LayoutDLine(textPtr, indexPtr); + DlineIndexOfX(textPtr, dlPtr, x + textPtr->dInfoPtr->x + - textPtr->dInfoPtr->curXPixelOffset, indexPtr); + FreeDLines(textPtr, dlPtr, NULL, DLINE_FREE_TEMP); +} + +/* + *---------------------------------------------------------------------- + * + * DlineXOfIndex -- + * + * Given a relative byte index on a given display line (i.e. the + * number of byte indices from the beginning of the given display + * line), find the x coordinate of that index within the abstract + * display line, without adjusting for the x-scroll state of the + * line. + * + * This is effectively the opposite of DlineIndexOfX. + * + * NB. The 'byteIndex' is relative to the display line, NOT the + * logical line. + * + * Results: + * The x coordinate. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static int +DlineXOfIndex(textPtr, dlPtr, byteIndex) + TkText *textPtr; /* Widget record for text widget. */ + DLine *dlPtr; /* Display information for this + * display line. */ + int byteIndex; /* The byte index for which we want the + * coordinate. */ +{ + TextDInfo *dInfoPtr = textPtr->dInfoPtr; + register TkTextDispChunk *chunkPtr; + TkTextIndex index; + int x; + + if (byteIndex == 0) return 0; + + /* + * Scan through the line's chunks to find the one that contains + * the desired byte index. + */ + + index = dlPtr->index; + chunkPtr = dlPtr->chunkPtr; + while (byteIndex > 0) { + if (byteIndex < chunkPtr->numBytes) { + int y, width, height; + (*chunkPtr->bboxProc)(chunkPtr, byteIndex, + dlPtr->y + dlPtr->spaceAbove, + dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow, + dlPtr->baseline - dlPtr->spaceAbove, &x, &y, &width, + &height); + break; + } else { + byteIndex -= chunkPtr->numBytes; + } + if (chunkPtr->nextPtr == NULL || byteIndex == 0) { + x = chunkPtr->x + chunkPtr->width; + break; + } + chunkPtr = chunkPtr->nextPtr; + } + + return x; +} + +/* + *---------------------------------------------------------------------- + * * TkTextCharBbox -- * * Given an index, find the bounding box of the screen area @@ -4228,13 +5782,18 @@ TkTextPixelIndex(textPtr, x, y, indexPtr) */ int -TkTextCharBbox(textPtr, indexPtr, xPtr, yPtr, widthPtr, heightPtr) +TkTextCharBbox(textPtr, indexPtr, xPtr, yPtr, widthPtr, heightPtr, charWidthPtr) TkText *textPtr; /* Widget record for text widget. */ CONST TkTextIndex *indexPtr;/* Index of character whose bounding * box is desired. */ int *xPtr, *yPtr; /* Filled with character's upper-left * coordinate. */ int *widthPtr, *heightPtr; /* Filled in with character's dimensions. */ + int *charWidthPtr; /* If the 'character' isn't really a + * character (e.g. end of a line) and + * therefore takes up a very large + * width, this is used to return a + * smaller width */ { TextDInfo *dInfoPtr = textPtr->dInfoPtr; DLine *dlPtr; @@ -4286,17 +5845,24 @@ TkTextCharBbox(textPtr, indexPtr, xPtr, yPtr, widthPtr, heightPtr) dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow, dlPtr->baseline - dlPtr->spaceAbove, xPtr, yPtr, widthPtr, heightPtr); - *xPtr = *xPtr + dInfoPtr->x - dInfoPtr->curPixelOffset; + *xPtr = *xPtr + dInfoPtr->x - dInfoPtr->curXPixelOffset; if ((byteIndex == (chunkPtr->numBytes - 1)) && (chunkPtr->nextPtr == NULL)) { /* * Last character in display line. Give it all the space up to * the line. */ + if (charWidthPtr != NULL) { + *charWidthPtr = dInfoPtr->maxX - *xPtr; + } if (*xPtr > dInfoPtr->maxX) { *xPtr = dInfoPtr->maxX; } *widthPtr = dInfoPtr->maxX - *xPtr; + } else { + if (charWidthPtr != NULL) { + *charWidthPtr = *widthPtr; + } } if ((*xPtr + *widthPtr) <= dInfoPtr->x) { return -1; @@ -4369,7 +5935,7 @@ TkTextDLineInfo(textPtr, indexPtr, xPtr, yPtr, widthPtr, heightPtr, basePtr) } dlx = (dlPtr->chunkPtr != NULL? dlPtr->chunkPtr->x: 0); - *xPtr = dInfoPtr->x - dInfoPtr->curPixelOffset + dlx; + *xPtr = dInfoPtr->x - dInfoPtr->curXPixelOffset + dlx; *widthPtr = dlPtr->length - dlx; *yPtr = dlPtr->y; if ((dlPtr->y + dlPtr->height) > dInfoPtr->maxY) { @@ -4454,8 +6020,9 @@ TkTextCharLayoutProc(textPtr, indexPtr, segPtr, byteOffset, maxX, maxBytes, * many characters. */ int noCharsYet; /* Non-zero means no characters have been * assigned to this display line yet. */ - TkWrapMode wrapMode; /* How to handle line wrapping: TEXT_WRAPMODE_CHAR, - * TEXT_WRAPMODE_NONE, or TEXT_WRAPMODE_WORD. */ + TkWrapMode wrapMode; /* How to handle line wrapping: + * TEXT_WRAPMODE_CHAR, * TEXT_WRAPMODE_NONE, + * or TEXT_WRAPMODE_WORD. */ register TkTextDispChunk *chunkPtr; /* Structure to fill in with information * about this chunk. The x field has already @@ -4643,7 +6210,8 @@ CharDisplayProc(chunkPtr, x, y, height, baseline, display, dst, screenY) * Draw the text, underline, and overstrike for this chunk. */ - if (!sValuePtr->elide && (ciPtr->numBytes > offsetBytes) && (stylePtr->fgGC != None)) { + if (!sValuePtr->elide && (ciPtr->numBytes > offsetBytes) + && (stylePtr->fgGC != None)) { int numBytes = ciPtr->numBytes - offsetBytes; char *string = ciPtr->chars + offsetBytes; @@ -4759,7 +6327,7 @@ static void CharBboxProc(chunkPtr, byteIndex, y, lineHeight, baseline, xPtr, yPtr, widthPtr, heightPtr) TkTextDispChunk *chunkPtr; /* Chunk containing desired char. */ - int byteIndex; /* Byte offset of desired character + int byteIndex; /* Byte offset of desired character * within the chunk. */ int y; /* Topmost pixel in area allocated * for this line. */ @@ -5235,3 +6803,102 @@ MeasureChars(tkfont, source, maxBytes, startX, maxX, tabOrigin, nextXPtr) *nextXPtr = curX; return start - source; } + +/* + *---------------------------------------------------------------------- + * + * TextGetScrollInfoObj -- + * + * This procedure is invoked to parse "yview" scrolling commands for + * text widgets using the new scrolling command syntax ("moveto" or + * "scroll" options). It extends the public Tk_GetScrollInfoObj + * function with the addition of "pixels" as a valid unit alongside + * "pages" and "units". It is a shame the core API isn't more + * flexible in this regard. + * + * Results: + * The return value is either TKTEXT_SCROLL_MOVETO, + * TKTEXT_SCROLL_PAGES, TKTEXT_SCROLL_UNITS, TKTEXT_SCROLL_PIXELS or + * TKTEXT_SCROLL_ERROR. This indicates whether the command was + * successfully parsed and what form the command took. If + * TKTEXT_SCROLL_MOVETO, *dblPtr is filled in with the desired + * position; if TKTEXT_SCROLL_PAGES, TKTEXT_SCROLL_PIXELS or + * TKTEXT_SCROLL_UNITS, *intPtr is filled in with the number of + * pages/pixels/lines to move (may be negative); if + * TKTEXT_SCROLL_ERROR, the interp's result contains an error + * message. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static int +TextGetScrollInfoObj(interp, textPtr, objc, objv, dblPtr, intPtr) + Tcl_Interp *interp; /* Used for error reporting. */ + TkText *textPtr; /* Information about the text + * widget. */ + int objc; /* # arguments for command. */ + Tcl_Obj *CONST objv[]; /* Arguments for command. */ + double *dblPtr; /* Filled in with argument "moveto" + * option, if any. */ + int *intPtr; /* Filled in with number of pages + * or lines or pixels to scroll, + * if any. */ +{ + char c; + size_t length; + CONST char *arg2; + + arg2 = Tcl_GetStringFromObj(objv[2], &length); + c = arg2[0]; + if ((c == 'm') && (strncmp(arg2, "moveto", length) == 0)) { + if (objc != 4) { + Tcl_WrongNumArgs(interp, 2, objv, "moveto fraction"); + return TKTEXT_SCROLL_ERROR; + } + if (Tcl_GetDoubleFromObj(interp, objv[3], dblPtr) != TCL_OK) { + return TKTEXT_SCROLL_ERROR; + } + return TKTEXT_SCROLL_MOVETO; + } else if ((c == 's') && (strncmp(arg2, "scroll", length) == 0)) { + CONST char *arg4; + + if (objc != 5) { + Tcl_WrongNumArgs(interp, 2, objv, + "scroll number units|pages|pixels"); + return TKTEXT_SCROLL_ERROR; + } + arg4 = Tcl_GetStringFromObj(objv[4], &length); + c = arg4[0]; + if ((c == 'p') && (length == 1)) { + Tcl_AppendResult(interp, "ambiguous argument \"", arg4, + "\": must be units, pages or pixels", (char *) NULL); + return TKTEXT_SCROLL_ERROR; + } else if ((c == 'p') && (strncmp(arg4, "pages", length) == 0)) { + if (Tcl_GetIntFromObj(interp, objv[3], intPtr) != TCL_OK) { + return TKTEXT_SCROLL_ERROR; + } + return TKTEXT_SCROLL_PAGES; + } else if ((c == 'p') && (strncmp(arg4, "pixels", length) == 0)) { + if (Tk_GetPixelsFromObj(interp, textPtr->tkwin, objv[3], + intPtr) != TCL_OK) { + return TKTEXT_SCROLL_ERROR; + } + return TKTEXT_SCROLL_PIXELS; + } else if ((c == 'u') && (strncmp(arg4, "units", length) == 0)) { + if (Tcl_GetIntFromObj(interp, objv[3], intPtr) != TCL_OK) { + return TKTEXT_SCROLL_ERROR; + } + return TKTEXT_SCROLL_UNITS; + } else { + Tcl_AppendResult(interp, "bad argument \"", arg4, + "\": must be units, pages or pixels", (char *) NULL); + return TKTEXT_SCROLL_ERROR; + } + } + Tcl_AppendResult(interp, "unknown option \"", arg2, + "\": must be moveto or scroll", (char *) NULL); + return TKTEXT_SCROLL_ERROR; +} |