fix to newline eliding in text widget

5 files changed, 402 insertions, 106 deletions

diff --git a/generic/tkText.c b/generic/tkText.c
index 9f1f6ac..8067165 100644
--- a/generic/tkText.c
+++ b/generic/tkText.c
@@ -14,7 +14,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkText.c,v 1.55 2004/11/15 13:09:07 vincentdarley Exp $
+ * RCS: @(#) $Id: tkText.c,v 1.56 2005/02/14 23:00:29 vincentdarley Exp $
  */
 
 #include "default.h"
@@ -905,9 +905,25 @@ TextWidgetObjCmd(clientData, interp, objc, objv)
 		     * Caution: we must NEVER call TkTextUpdateOneLine
 		     * with the last artificial line in the widget.
 		     */
-		    while (fromPtr != indexToPtr->linePtr) {
-			value += TkTextUpdateOneLine(textPtr, fromPtr, 0, NULL);
-			fromPtr = TkBTreeNextLine(textPtr, fromPtr);
+		    index = *indexFromPtr;
+		    while (index.linePtr != indexToPtr->linePtr) {
+			value += TkTextUpdateOneLine(textPtr, fromPtr, 
+						     0, &index, 0);
+			/* 
+			 * We might have skipped past indexToPtr, if we
+			 * have multiple logical lines in a single
+			 * display line.  Therefore we iterate through
+			 * each intermediate logical line, just to
+			 * check.  Another approach would be just to use
+			 * TkTextIndexCmp on every while() iteration,
+			 * but that would be less efficient.
+			 */
+			while (fromPtr != index.linePtr) {
+			    fromPtr = TkBTreeNextLine(textPtr, fromPtr);
+			    if (fromPtr == indexToPtr->linePtr) {
+			        break;
+			    }
+			}
 		    }
 		    /* 
 		     * Now we need to adjust the count to add on the
diff --git a/generic/tkText.h b/generic/tkText.h
index 14b2a71..5d7ea0f 100644
--- a/generic/tkText.h
+++ b/generic/tkText.h
@@ -10,7 +10,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkText.h,v 1.25 2004/09/10 12:13:41 vincentdarley Exp $
+ * RCS: @(#) $Id: tkText.h,v 1.26 2005/02/14 23:00:44 vincentdarley Exp $
  */
 
 #ifndef _TKTEXT
@@ -1000,7 +1000,8 @@ EXTERN Tk_SegType	tkTextToggleOffType;
  */
   
 EXTERN int		TkBTreeAdjustPixelHeight _ANSI_ARGS_((CONST TkText *textPtr,
-			    TkTextLine *linePtr, int newPixelHeight));
+			    TkTextLine *linePtr, int newPixelHeight,
+			    int mergedLogicalLines));
 EXTERN int		TkBTreeCharTagged _ANSI_ARGS_((CONST TkTextIndex *indexPtr,
 			    TkTextTag *tagPtr));
 EXTERN void		TkBTreeCheck _ANSI_ARGS_((TkTextBTree tree));
@@ -1095,7 +1096,7 @@ EXTERN TkTextTabArray *	TkTextGetTabs _ANSI_ARGS_((Tcl_Interp *interp,
 EXTERN void             TkTextFindDisplayLineEnd _ANSI_ARGS_((
 			    TkText *textPtr, TkTextIndex *indexPtr, 
 			    int end, int *xOffset));
-EXTERN void		TkTextIndexBackBytes _ANSI_ARGS_((CONST TkText *textPtr, 
+EXTERN int		TkTextIndexBackBytes _ANSI_ARGS_((CONST TkText *textPtr, 
 			    CONST TkTextIndex *srcPtr, int count,
 			    TkTextIndex *dstPtr));
 EXTERN void		TkTextIndexBackChars _ANSI_ARGS_((
@@ -1150,7 +1151,7 @@ EXTERN int              TkTextUpdateLineMetrics _ANSI_ARGS_((TkText *textPtr,
 			    int lineNum, int endLine, int doThisMuch));
 EXTERN int              TkTextUpdateOneLine _ANSI_ARGS_((TkText *textPtr, 
 			    TkTextLine *linePtr, int pixelHeight, 
-			    TkTextIndex *indexPtr));
+			    TkTextIndex *indexPtr, int partialCalc));
 EXTERN int		TkTextMarkCmd _ANSI_ARGS_((TkText *textPtr,
 			    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]));
 EXTERN int		TkTextMarkNameToIndex _ANSI_ARGS_((TkText *textPtr,
diff --git a/generic/tkTextBTree.c b/generic/tkTextBTree.c
index 964dfcd..1919849 100644
--- a/generic/tkTextBTree.c
+++ b/generic/tkTextBTree.c
@@ -11,7 +11,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkTextBTree.c,v 1.15 2004/09/10 12:13:41 vincentdarley Exp $
+ * RCS: @(#) $Id: tkTextBTree.c,v 1.16 2005/02/14 23:00:44 vincentdarley Exp $
  */
 
 #include "tkInt.h"
@@ -919,11 +919,19 @@ DeleteSummaries(summaryPtr)
  */
 
 int
-TkBTreeAdjustPixelHeight(textPtr, linePtr, newPixelHeight)
+TkBTreeAdjustPixelHeight(textPtr, linePtr, newPixelHeight, mergedLogicalLines)
     CONST TkText *textPtr;              /* Client of the B-tree */
     register TkTextLine *linePtr;	/* The logical line to update */
     int newPixelHeight;			/* The line's known height 
                        			 * in pixels */
+    int mergedLogicalLines;             /* The number of extra logical
+                                         * lines which have been merged
+                                         * with this one (due to elided
+                                         * eols).  They will have their
+                                         * pixel height set to zero, and
+                                         * the total pixel height
+                                         * associated with the given
+                                         * linePtr.  */
 {
     register Node *nodePtr;
     int changeToPixelCount;		/* Counts change to total number of
@@ -947,6 +955,17 @@ TkBTreeAdjustPixelHeight(textPtr, linePtr, newPixelHeight)
 
     linePtr->pixels[2*pixelReference] = newPixelHeight;
     
+    /* 
+     * Any merged logical lines must have their height set to zero. 
+     */
+    while (mergedLogicalLines-- > 0) {
+        linePtr = TkBTreeNextLine(textPtr, linePtr);
+	TkBTreeAdjustPixelHeight(textPtr, linePtr, 0, 0);
+    }
+    
+    /*
+     * Return total number of pixels in the tree.
+     */
     return nodePtr->numPixels[pixelReference];
 }
 
@@ -1161,11 +1180,14 @@ SplitSeg(indexPtr)
 					 * at which to split a segment. */
 {
     TkTextSegment *prevPtr, *segPtr;
-    int count;
-
-    for (count = indexPtr->byteIndex, prevPtr = NULL,
-	    segPtr = indexPtr->linePtr->segPtr; segPtr != NULL;
-	    count -= segPtr->size, prevPtr = segPtr, segPtr = segPtr->nextPtr) {
+    TkTextLine *linePtr;
+    
+    int count = indexPtr->byteIndex;
+    linePtr = indexPtr->linePtr;
+    prevPtr = NULL;
+    segPtr = linePtr->segPtr;
+    
+    while (segPtr != NULL) {
 	if (segPtr->size > count) {
 	    if (count == 0) {
 		return prevPtr;
@@ -1181,6 +1203,21 @@ SplitSeg(indexPtr)
 		&& !segPtr->typePtr->leftGravity) {
 	    return prevPtr;
 	}
+    
+	count -= segPtr->size;
+	prevPtr = segPtr;
+	segPtr = segPtr->nextPtr;
+	if (segPtr == NULL) {
+	    /* 
+	     * Two logical lines merged into one display line 
+	     * through eliding of a newline
+	     */
+	    linePtr = TkBTreeNextLine(NULL, linePtr);
+	    if (linePtr == NULL) {
+		/* Reached end of the text */
+	    }
+	    segPtr = linePtr->segPtr;
+	}
     }
     Tcl_Panic("SplitSeg reached end of line!");
     return NULL;
@@ -2014,9 +2051,18 @@ TkBTreeUnlinkSegment(segPtr, linePtr)
     if (linePtr->segPtr == segPtr) {
 	linePtr->segPtr = segPtr->nextPtr;
     } else {
-	for (prevPtr = linePtr->segPtr; prevPtr->nextPtr != segPtr;
-		prevPtr = prevPtr->nextPtr) {
-	    /* Empty loop body. */
+	prevPtr = linePtr->segPtr;
+	while (prevPtr->nextPtr != segPtr) {
+	    prevPtr = prevPtr->nextPtr;
+	    
+	    if (prevPtr == NULL) {
+		/* 
+		 * Two logical lines merged into one display line 
+		 * through eliding of a newline
+		 */
+		linePtr = TkBTreeNextLine(NULL, linePtr);
+		prevPtr = linePtr->segPtr;
+	    }
 	}
 	prevPtr->nextPtr = segPtr->nextPtr;
     }
@@ -3251,6 +3297,7 @@ TkBTreeGetTags(indexPtr, textPtr, numTagsPtr)
     register Node *nodePtr;
     register TkTextLine *siblingLinePtr;
     register TkTextSegment *segPtr;
+    TkTextLine *linePtr;
     int src, dst, index;
     TagInfo tagInfo;
 #define NUM_TAG_INFOS 10
@@ -3267,13 +3314,25 @@ TkBTreeGetTags(indexPtr, textPtr, numTagsPtr)
      * indexPtr.
      */
 
-    for (index = 0, segPtr = indexPtr->linePtr->segPtr;
-	    (index + segPtr->size) <= indexPtr->byteIndex;
-	    index += segPtr->size, segPtr = segPtr->nextPtr) {
+    linePtr = indexPtr->linePtr;
+    index = 0;
+    segPtr = linePtr->segPtr;
+    while ((index + segPtr->size) <= indexPtr->byteIndex) {
 	if ((segPtr->typePtr == &tkTextToggleOnType)
 		|| (segPtr->typePtr == &tkTextToggleOffType)) {
 	    IncCount(segPtr->body.toggle.tagPtr, 1, &tagInfo);
 	}
+	index += segPtr->size;
+	segPtr = segPtr->nextPtr;
+	
+	if (segPtr == NULL) {
+	    /* 
+	     * Two logical lines merged into one display line 
+	     * through eliding of a newline
+	     */
+	    linePtr = TkBTreeNextLine(NULL, linePtr);
+	    segPtr = linePtr->segPtr;
+	}
     }
 
     /*
@@ -3389,6 +3448,7 @@ TkTextIsElided(textPtr, indexPtr, elideInfo)
     register TkTextTag *tagPtr = NULL;
     register int i, index;
     register TkTextElideInfo *infoPtr;
+    TkTextLine *linePtr;
     int elide;
     
     if (elideInfo == NULL) {
@@ -3419,9 +3479,10 @@ TkTextIsElided(textPtr, indexPtr, elideInfo)
      * indexPtr.
      */
 
-    for (index = 0, segPtr = indexPtr->linePtr->segPtr;
-	 (index + segPtr->size) <= indexPtr->byteIndex;
-	 index += segPtr->size, segPtr = segPtr->nextPtr) {
+    index = 0;
+    linePtr = indexPtr->linePtr;
+    segPtr = linePtr->segPtr;
+    while ((index + segPtr->size) <= indexPtr->byteIndex) {
 	if ((segPtr->typePtr == &tkTextToggleOnType)
 		|| (segPtr->typePtr == &tkTextToggleOffType)) {
 	    tagPtr = segPtr->body.toggle.tagPtr;
@@ -3430,6 +3491,17 @@ TkTextIsElided(textPtr, indexPtr, elideInfo)
 		infoPtr->tagCnts[tagPtr->priority]++;
 	    }
 	}
+       
+	index += segPtr->size;
+	segPtr = segPtr->nextPtr;
+	if (segPtr == NULL) {
+	    /* 
+	     * Two logical lines merged into one display line 
+	     * through eliding of a newline
+	     */
+	    linePtr = TkBTreeNextLine(NULL, linePtr);
+	    segPtr = linePtr->segPtr;
+	}
     }
     /* 
      * Store the first segPtr we haven't examined completely
diff --git a/generic/tkTextDisp.c b/generic/tkTextDisp.c
index b585534..bef5148 100644
--- a/generic/tkTextDisp.c
+++ b/generic/tkTextDisp.c
@@ -13,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.46 2005/01/11 16:00:14 vincentdarley Exp $
+ * RCS: @(#) $Id: tkTextDisp.c,v 1.47 2005/02/14 23:00:44 vincentdarley Exp $
  */
 
 #include "tkPort.h"
@@ -165,6 +165,8 @@ typedef struct DLine {
     int byteCount;		/* Number of bytes accounted for by this
 				 * display line, including a trailing space
 				 * or newline that isn't actually displayed. */
+    int logicalLinesMerged;     /* Number of extra logical lines merged 
+                                 * into this one due to elided newlines. */
     int y;			/* Y-position at which line is supposed to
 				 * be drawn (topmost pixel of rectangular
 				 * area occupied by line). */
@@ -508,7 +510,7 @@ static void             TextInvalidateLineMetrics _ANSI_ARGS_((TkText *textPtr,
 			    TkTextLine *linePtr, int lineCount, int action));
 static int              CalculateDisplayLineHeight _ANSI_ARGS_((
 			    TkText *textPtr, CONST TkTextIndex *indexPtr, 
-			    int *byteCountPtr));
+			    int *byteCountPtr, int *mergedLinePtr));
 static void             DlineIndexOfX _ANSI_ARGS_((TkText *textPtr, 
 			    DLine *dlPtr, int x, TkTextIndex *indexPtr));
 static int              DlineXOfIndex _ANSI_ARGS_((TkText *textPtr, 
@@ -1031,7 +1033,8 @@ LayoutDLine(textPtr, indexPtr)
     dlPtr->chunkPtr = NULL;
     dlPtr->nextPtr = NULL;
     dlPtr->flags = NEW_LAYOUT | OLD_Y_INVALID;
-
+    dlPtr->logicalLinesMerged = 0;
+    
     /*
      * Special case entirely elide line as there may be 1000s or more
      */
@@ -1115,7 +1118,7 @@ LayoutDLine(textPtr, indexPtr)
 
 		if (TkBTreeLinePixelCount(textPtr, dlPtr->index.linePtr) != 0) {
 		    TkBTreeAdjustPixelHeight(textPtr, 
-					     dlPtr->index.linePtr, 0);
+					     dlPtr->index.linePtr, 0, 0);
 		}
 	    }
 	    TkTextFreeElideInfo(&info);
@@ -1146,17 +1149,35 @@ LayoutDLine(textPtr, indexPtr)
     wrapMode = TEXT_WRAPMODE_CHAR;
     tabSize = 0;
     lastCharChunkPtr = NULL;
-
+    
     /*
      * Find the first segment to consider for the line.  Can't call
      * TkTextIndexToSeg for this because it won't return a segment
      * with zero size (such as the insertion cursor's mark).
      */
 
-    for (byteOffset = curIndex.byteIndex, segPtr = curIndex.linePtr->segPtr;
-	 (byteOffset > 0) && (byteOffset >= segPtr->size);
-	 byteOffset -= segPtr->size, segPtr = segPtr->nextPtr) {
-	/* Empty loop body. */
+  connectNextLogicalLine:
+    byteOffset = curIndex.byteIndex;
+    segPtr = curIndex.linePtr->segPtr;
+    while ((byteOffset > 0) && (byteOffset >= segPtr->size)) {
+	byteOffset -= segPtr->size;
+	segPtr = segPtr->nextPtr;
+	
+	if (segPtr == NULL) {
+	    /* 
+	     * Two logical lines merged into one display line 
+	     * through eliding of a newline
+	     */
+	    TkTextLine *linePtr = TkBTreeNextLine(NULL, curIndex.linePtr);
+	    if (linePtr != NULL) {
+		dlPtr->logicalLinesMerged++;
+		curIndex.byteIndex = 0;
+		curIndex.linePtr = linePtr;
+		segPtr = curIndex.linePtr->segPtr;
+	    } else {
+		break;
+	    }
+	}
     }
 
     while (segPtr != NULL) {
@@ -1168,11 +1189,10 @@ LayoutDLine(textPtr, indexPtr)
 	 * 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. 
+	 * elided still gets laid out into a DLine, but with zero
+	 * height.  This isn't particularly a problem, but it does seem
+	 * somewhat unnecessary.  We may wish to redesign the code to
+	 * remove these zero height DLines in the future.
 	 */
 	if (elide && (lastChunkPtr != NULL)
 		&& (lastChunkPtr->displayProc == NULL /*ElideDisplayProc*/)) {
@@ -1195,9 +1215,26 @@ LayoutDLine(textPtr, indexPtr)
 
 	    byteOffset = 0;
 	    segPtr = segPtr->nextPtr;
+	    
+	    if (segPtr == NULL) {
+		/* 
+		 * Two logical lines merged into one display line 
+		 * through eliding of a newline
+		 */
+		TkTextLine *linePtr = TkBTreeNextLine(NULL, curIndex.linePtr);
+		if (linePtr != NULL) {
+		    dlPtr->logicalLinesMerged++;
+		    curIndex.byteIndex = 0;
+		    curIndex.linePtr = linePtr;
+		    goto connectNextLogicalLine;
+		}
+	    }
+	    /* Code no longer needed, now that we allow logical lines
+	     * to merge into a single display line.
 	    if (segPtr == NULL && chunkPtr != NULL) {
 		ckfree((char *) chunkPtr);
-	    }
+		chunkPtr = NULL;
+	    }*/
 	    continue;
 	}
 
@@ -1350,19 +1387,36 @@ LayoutDLine(textPtr, indexPtr)
 	    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]
+		 * until the newline.  Hence the newline is actually
+		 * elided, and we want to merge the display of the next
+		 * logical line with this one.
 		 */
+		TkTextLine *linePtr = TkBTreeNextLine(NULL, curIndex.linePtr);
+		if (linePtr != NULL) {
+		    dlPtr->logicalLinesMerged++;
+		    curIndex.byteIndex = 0;
+		    curIndex.linePtr = linePtr;
+		    chunkPtr = NULL;
+		    goto connectNextLogicalLine;
+		}
 	    }
 	}
 
 	chunkPtr = NULL;
     }
     if (noCharsYet) {
-	Tcl_Panic("LayoutDLine couldn't place any characters on a line");
+	dlPtr->spaceAbove = 0;
+	dlPtr->spaceBelow = 0;
+	dlPtr->length = 0;
+	/* 
+	 * We used to Tcl_Panic here, saying that LayoutDLine couldn't
+	 * place any characters on a line, but I believe a more
+	 * appropriate response is to return a DLine with zero height.
+	 * With elided lines, tag transitions and asynchronous line
+	 * height calculations, it is hard to avoid this situation ever
+	 * arising with the current code design.
+	 */
+	return dlPtr;
     }
     wholeLine = (segPtr == NULL);
 
@@ -1704,7 +1758,7 @@ UpdateDisplayInfo(textPtr)
 		 */
 		TkBTreeAdjustPixelHeight(textPtr, 
 					 prevPtr->index.linePtr, 
-					 lineHeight);
+					 lineHeight, 0);
 		/* 
 		 * I believe we can be 100% sure that we started at the
 		 * beginning of the logical line, so we can also adjust
@@ -1826,7 +1880,7 @@ UpdateDisplayInfo(textPtr)
 							lowestPtr->index.linePtr)) {
 		    TkBTreeAdjustPixelHeight(textPtr, 
 					     lowestPtr->index.linePtr, 
-					     pixelHeight);
+					     pixelHeight, 0);
 		    if (index.linePtr != lowestPtr->index.linePtr) {
 			/* 
 			 * We examined the entire line, so can update
@@ -2796,7 +2850,7 @@ TkTextUpdateLineMetrics(textPtr, lineNum, endLine, doThisMuch)
 		!= textPtr->dInfoPtr->lineMetricUpdateEpoch) {
 		if (doThisMuch == -1) {
 		    count += 8 * TkTextUpdateOneLine(textPtr, linePtr, 
-						     0, NULL);
+						     0, NULL, 0);
 		} else {
 		    TkTextIndex index;
 		    TkTextIndex *indexPtr;
@@ -2834,7 +2888,7 @@ TkTextUpdateLineMetrics(textPtr, lineNum, endLine, doThisMuch)
 		     * 8 for each display line we actually re-layout.
 		     */
 		    count += 8 * TkTextUpdateOneLine(textPtr, linePtr, 
-						     pixelHeight, indexPtr);
+						     pixelHeight, indexPtr, 1);
 		    
 		    if (indexPtr->linePtr == linePtr) {
 			/* 
@@ -3082,11 +3136,7 @@ TextInvalidateLineMetrics(textPtr, linePtr, lineCount, action)
  *	
  *	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).
+ *	be the last elided index on the display line.
  *	
  * Results:
  *	Modifies indexPtr to point to the given end.
@@ -3127,17 +3177,51 @@ TkTextFindDisplayLineEnd(textPtr, indexPtr, end, xOffset)
 	index.textPtr = NULL;
 	
 	while (1) {
+	    TkTextIndex endOfLastLine;
+	
+	    if (TkTextIndexBackBytes(textPtr, &index, 1, &endOfLastLine)) {
+		/* Reached beginning of text */
+		break;
+	    }
+
+	    if (!TkTextIsElided(textPtr, &endOfLastLine, NULL)) {
+		/*
+		 * The eol is not elided, so 'index' points to
+		 * the start of a display line (as well as logical
+		 * line).
+		 */
+		break;
+	    }
+	    /* 
+	     * indexPtr's logical line is actually merged with
+	     * the previous logical line whose eol is elided.
+	     * Continue searching back to get a real line start.
+	     */
+	    index = endOfLastLine;
+	    index.byteIndex = 0;
+	}
+
+	while (1) {
 	    DLine *dlPtr;
 	    int byteCount;
+	    TkTextIndex nextLineStart;
 	    
 	    dlPtr = LayoutDLine(textPtr, &index);
 	    byteCount = dlPtr->byteCount;
-
+	    
+	    TkTextIndexForwBytes(textPtr, &index, byteCount, &nextLineStart);
+	    
 	    /* 
-	     * 'byteCount' goes up to the beginning of the next line,
-	     * so equality here says we need one more line
+	     * 'byteCount' goes up to the beginning of the next display
+	     * line, so equality here says we need one more line.  We
+	     * try to perform a quick comparison which is valid for 
+	     * the case where the logical line is the same, but 
+	     * otherwise fall back on a full TkTextIndexCmp.
 	     */
-	    if (index.byteIndex + byteCount > indexPtr->byteIndex) {
+	    if (((index.linePtr == indexPtr->linePtr) 
+		 && (index.byteIndex + byteCount > indexPtr->byteIndex))
+		|| (dlPtr->logicalLinesMerged > 0 
+		    && TkTextIndexCmp(&nextLineStart, indexPtr) > 0)) {
 		/* It's on this display line */
 		if (xOffset != NULL) {
 		    /* 
@@ -3149,19 +3233,20 @@ TkTextFindDisplayLineEnd(textPtr, indexPtr, end, xOffset)
 		    *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);
+		    TkTextIndexBackBytes(textPtr, &nextLineStart, 1, indexPtr);
+		} else {
+		    *indexPtr = index;
 		}
 		FreeDLines(textPtr, dlPtr, NULL, DLINE_FREE_TEMP);
 		return;
 	    }
 	    FreeDLines(textPtr, dlPtr, NULL, DLINE_FREE_TEMP);
-	    TkTextIndexForwBytes(textPtr, &index, byteCount, &index);
+	    index = nextLineStart;
 	}
     }
 }
@@ -3188,6 +3273,10 @@ TkTextFindDisplayLineEnd(textPtr, indexPtr, end, xOffset)
  *	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).
+ *	
+ *	If 'mergedLinePtr' is non-NULL, then returns in that pointer
+ *	the number of extra logical lines merged into the given
+ *	display line.
  *
  * Side effects:
  *	The combination of 'LayoutDLine' and 'FreeDLines' seems
@@ -3201,18 +3290,37 @@ TkTextFindDisplayLineEnd(textPtr, indexPtr, end, xOffset)
  */
 
 static int
-CalculateDisplayLineHeight(textPtr, indexPtr, byteCountPtr)
+CalculateDisplayLineHeight(textPtr, indexPtr, byteCountPtr, mergedLinePtr)
     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. */
+    int *mergedLinePtr;          /* NULL or used to return if the given
+                                  * display line merges with a following
+                                  * logical line (because the eol is 
+                                  * elided). */
 {
     DLine *dlPtr;
     int pixelHeight;
     
     /* 
+     * Special case for artificial last line.  May be better to move
+     * this inside LayoutDLine.
+     */
+    if (indexPtr->byteIndex == 0 
+      && TkBTreeNextLine(textPtr, indexPtr->linePtr) == NULL) {
+	if (byteCountPtr != NULL) {
+	    *byteCountPtr = 0;
+	}
+	if (mergedLinePtr != NULL) {
+	    *mergedLinePtr = 0;
+	}
+	return 0;
+    }
+
+    /* 
      * 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
@@ -3223,6 +3331,9 @@ CalculateDisplayLineHeight(textPtr, indexPtr, byteCountPtr)
     if (byteCountPtr != NULL) {
         *byteCountPtr = dlPtr->byteCount;
     }
+    if (mergedLinePtr != NULL) {
+        *mergedLinePtr = dlPtr->logicalLinesMerged;
+    }
     FreeDLines(textPtr, dlPtr, NULL, DLINE_FREE_TEMP);
 
     return pixelHeight;
@@ -3288,7 +3399,7 @@ TkTextIndexYPixels(textPtr, indexPtr)
 	 * specifically the 'linePtr->pixelHeight == pixelHeight' test 
 	 * below this while loop.
 	 */
-	height = CalculateDisplayLineHeight(textPtr, &index, &bytes);
+	height = CalculateDisplayLineHeight(textPtr, &index, &bytes, NULL);
 	
 	index.byteIndex += bytes;
 	
@@ -3334,7 +3445,7 @@ TkTextIndexYPixels(textPtr, indexPtr)
  */
 
 int
-TkTextUpdateOneLine(textPtr, linePtr, pixelHeight, indexPtr)
+TkTextUpdateOneLine(textPtr, linePtr, pixelHeight, indexPtr, partialCalc)
     TkText *textPtr;        /* Widget record for text widget. */
     TkTextLine *linePtr;    /* The line of which to calculate the
                              * height. */
@@ -3344,10 +3455,18 @@ TkTextUpdateOneLine(textPtr, linePtr, pixelHeight, indexPtr)
                              * has been given. */
     TkTextIndex *indexPtr;  /* Either NULL or an index at the start of
                              * a display line belonging to linePtr,
-                             * up to which we have already calculated. */
+                             * at which we wish to start (e.g. up to 
+                             * which we have already calculated). On
+                             * return this will be set to the first
+                             * index on the next line. */
+    int partialCalc;        /* Set to 1 if we are allowed to do 
+                             * partial height calculations of 
+                             * long-lines.  In this case we'll only
+                             * return what we know so far. */
 {
     TkTextIndex index;
-    int displayLines, partialCalc;
+    int displayLines;
+    int mergedLines;
     
     if (indexPtr == NULL) {
 	index.tree = textPtr->sharedTextPtr->tree;
@@ -3356,9 +3475,6 @@ TkTextUpdateOneLine(textPtr, linePtr, pixelHeight, indexPtr)
 	index.textPtr = NULL;
 	indexPtr = &index;
 	pixelHeight = 0;
-	partialCalc = 0; 
-    } else {
-	partialCalc = 1; 
     }
     
     /* 
@@ -3369,9 +3485,10 @@ TkTextUpdateOneLine(textPtr, linePtr, pixelHeight, indexPtr)
      */
 
     displayLines = 0;
+    mergedLines = 0;
     
     while (1) {
-	int bytes, height;
+	int bytes, height, logicalLines;
 	
 	/* 
 	 * Currently this call doesn't have many side-effects. 
@@ -3381,36 +3498,71 @@ TkTextUpdateOneLine(textPtr, linePtr, pixelHeight, indexPtr)
 	 * specifically the 'linePtr->pixelHeight == pixelHeight' test 
 	 * below this while loop.
 	 */
-	height = CalculateDisplayLineHeight(textPtr, indexPtr, &bytes);
+	height = CalculateDisplayLineHeight(textPtr, indexPtr, &bytes, 
+					    &logicalLines);
 	
 	if (height > 0) {
 	    pixelHeight += height;
 	    displayLines++;
 	}
 	
+	mergedLines += logicalLines;
+	
 	if (TkTextIndexForwBytes(textPtr, indexPtr, bytes, indexPtr)) {
             break;
         }
 
-	if (indexPtr->linePtr != linePtr) {
-	    /* 
-	     * If we reached the end of the logical line, then
-	     * either way we don't have a partial calculation.
+	if (logicalLines == 0) {
+	    if (indexPtr->linePtr != linePtr) {
+		/* 
+		 * If we reached the end of the logical line, then
+		 * either way we don't have a partial calculation.
+		 */
+		partialCalc = 0;
+		break;
+	    }
+	} else if (indexPtr->byteIndex != 0) {
+	    /* We must still be on the same wrapped line */
+	} else {
+	    /*
+	     * Must check if indexPtr is really a new logical line
+	     * which is not merged with the previous line.  The only
+	     * code that would really know this is LayoutDLine, which
+	     * doesn't pass the information on, so we have to check
+	     * manually here.
 	     */
-	    partialCalc = 0;
-	    break;
+	    TkTextIndex idx;
+	    TkTextIndexBackChars(textPtr, indexPtr, 1, &idx, COUNT_INDICES);
+	    if (!TkTextIsElided(textPtr, &idx, NULL)) {
+		/* We've ended a logical line */
+		partialCalc = 0;
+		break;
+	    }
+	    /* We must still be on the same wrapped line */
 	}
-	if (partialCalc && displayLines > 50) {
+	if (partialCalc && displayLines > 50 && mergedLines == 0) {
 	    /* 
 	     * Only calculate 50 display lines at a time, to 
 	     * avoid huge delays.  In any case it is very rare
 	     * that a single line wraps 50 times!
+	     * 
+	     * If we have any merged lines, we must complete the full
+	     * logical line layout here and now, because the
+	     * partial-calculation code isn't designed to handle merged
+	     * logical lines.  Hence the 'mergedLines == 0' check.
 	     */
 	    break;
 	}
     }
     
     if (!partialCalc) {
+	int changed = 0;
+	
+	/* 
+	 * Cancel any partial line height calculation state.
+	 */
+	textPtr->dInfoPtr->metricEpoch = -1;
+
 	/* 
 	 * Mark the logical line as being up to date (caution: it isn't
 	 * yet up to date, that will happen in TkBTreeAdjustPixelHeight
@@ -3418,12 +3570,33 @@ TkTextUpdateOneLine(textPtr, linePtr, pixelHeight, indexPtr)
 	 */
 	TkBTreeLinePixelEpoch(textPtr, linePtr) 
 	                   = textPtr->dInfoPtr->lineMetricUpdateEpoch;
-	/* 
-	 * Also cancel any partial line height calculation state.
-	 */
-	textPtr->dInfoPtr->metricEpoch = -1;
-
-	if (TkBTreeLinePixelCount(textPtr, linePtr) == pixelHeight) {
+	if (TkBTreeLinePixelCount(textPtr, linePtr) != pixelHeight) {
+	    changed = 1;
+	}
+	
+	if (mergedLines > 0) {
+	    int i = mergedLines;
+	    TkTextLine *mergedLinePtr;
+	    /* 
+	     * Loop over all merged logical lines, marking them up to date
+	     * (again, the pixel count setting will actually happen in 
+	     * TkBTreeAdjustPixelHeight).
+	     */
+	    mergedLinePtr = linePtr;
+	    while (i-- > 0) {
+		mergedLinePtr = TkBTreeNextLine(textPtr, mergedLinePtr);
+		TkBTreeLinePixelEpoch(textPtr, mergedLinePtr) 
+				   = textPtr->dInfoPtr->lineMetricUpdateEpoch;
+		if (TkBTreeLinePixelCount(textPtr, mergedLinePtr) != 0) {
+		    changed = 1;
+		}
+	    }
+	}
+	
+	if (!changed) {
+	    /* 
+	     * If there's nothing to change, then we can already return.
+	     */
 	    return displayLines;
 	}
     }
@@ -3433,8 +3606,8 @@ TkTextUpdateOneLine(textPtr, linePtr, pixelHeight, indexPtr)
      * of the entire widget, which may be used just below for
      * reporting/debugging purposes.
      */
-    pixelHeight = TkBTreeAdjustPixelHeight(textPtr,  
-					   linePtr, pixelHeight);
+    pixelHeight = TkBTreeAdjustPixelHeight(textPtr, linePtr, 
+					   pixelHeight, mergedLines);
     
     if (tkTextDebug) {
 	char buffer[2 * TCL_INTEGER_SPACE + 1];
@@ -4661,7 +4834,7 @@ TkTextSetYView(textPtr, indexPtr, pickPlace)
      * window.  
      */
 
-    lineHeight = CalculateDisplayLineHeight(textPtr, indexPtr, NULL);
+    lineHeight = CalculateDisplayLineHeight(textPtr, indexPtr, NULL, NULL);
     /* 
      * It would be better if 'bottomY' were calculated using the
      * actual height of the given line, not 'textPtr->charHeight'.
@@ -5139,7 +5312,7 @@ YScrollByPixels(textPtr, offset)
 	 * negative here.
 	 */
 	offset -= CalculateDisplayLineHeight(textPtr, 
-		&textPtr->topIndex, NULL) - dInfoPtr->topPixelOffset;
+		&textPtr->topIndex, NULL, NULL) - dInfoPtr->topPixelOffset;
 	MeasureUp(textPtr, &textPtr->topIndex, -offset, 
 		&textPtr->topIndex, &dInfoPtr->newTopPixelOffset);
     } else if (offset > 0) {
@@ -6193,26 +6366,38 @@ DlineIndexOfX(textPtr, dlPtr, x, indexPtr)
     x = x - dInfoPtr->x + dInfoPtr->curXPixelOffset;
     chunkPtr = dlPtr->chunkPtr;
 
-    if (chunkPtr == NULL) {
+    if (chunkPtr == NULL || x == 0) {
 	/* 
-	 * This may occur if everything is elided
+	 * This may occur if everything is elided, or if we're simply
+	 * already at the beginning of the line.
 	 */
 	return;
     }
 
-    for (; x >= (chunkPtr->x + chunkPtr->width);
-	    indexPtr->byteIndex += chunkPtr->numBytes,
-	    chunkPtr = chunkPtr->nextPtr) {
+    while (x >= (chunkPtr->x + chunkPtr->width)) {
+	/* 
+	 * Note that this forward then backward movement of the index
+	 * can be problematic at the end of the buffer (we can't move
+	 * forward, and then when we move backward, we do, leading to
+	 * the wrong position).  Hence when x == 0 we take special
+	 * action above.
+	 */
+	if (TkTextIndexForwBytes(NULL, indexPtr, chunkPtr->numBytes, indexPtr)) {
+	    /* We've reached the end of the text */
+	    return;
+	}
 	if (chunkPtr->nextPtr == NULL) {
-	    indexPtr->byteIndex += chunkPtr->numBytes;
 	    TkTextIndexBackChars(NULL, indexPtr, 1, indexPtr, COUNT_INDICES);
 	    return;
 	}
+	chunkPtr = chunkPtr->nextPtr;
     }
 
     /*
      * If the chunk has more than one byte in it, ask it which
-     * character is at the desired location.
+     * character is at the desired location.  In this case we
+     * can manipulate 'indexPtr->byteIndex' directly, because
+     * we know we're staying inside a single logical line.
      */
 
     if (chunkPtr->numBytes > 1) {
diff --git a/generic/tkTextIndex.c b/generic/tkTextIndex.c
index ed52e98..e9469ee 100644
--- a/generic/tkTextIndex.c
+++ b/generic/tkTextIndex.c
@@ -10,7 +10,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkTextIndex.c,v 1.20 2004/10/05 01:26:10 hobbs Exp $
+ * RCS: @(#) $Id: tkTextIndex.c,v 1.21 2005/02/14 23:00:46 vincentdarley Exp $
  */
 
 #include "default.h"
@@ -1016,11 +1016,21 @@ TkTextPrintIndex(textPtr, indexPtr, string)
 				 * at least TK_POS_CHARS characters. */
 {
     TkTextSegment *segPtr;
+    TkTextLine *linePtr;
     int numBytes, charIndex;
 
     numBytes = indexPtr->byteIndex;
     charIndex = 0;
-    for (segPtr = indexPtr->linePtr->segPtr; ; segPtr = segPtr->nextPtr) {
+    linePtr = indexPtr->linePtr;
+    for (segPtr = linePtr->segPtr; ; segPtr = segPtr->nextPtr) {
+	if (segPtr == NULL) {
+	    /* 
+	     * Two logical lines merged into one display line 
+	     * through eliding of a newline
+	     */
+	    linePtr = TkBTreeNextLine(NULL, linePtr);
+	    segPtr = linePtr->segPtr;
+	}
 	if (numBytes <= segPtr->size) {
 	    break;
 	}
@@ -1777,6 +1787,9 @@ TkTextIndexCount(textPtr, indexPtr1, indexPtr2, type)
  *	*dstPtr is modified to refer to the character "count" bytes before
  *	srcPtr, or to the first character in the TkText if there aren't
  *	"count" bytes earlier than srcPtr.
+ *	
+ *	Returns 1 if we couldn't use all of 'byteCount' because we 
+ *	have run into the beginning or end of the text, and zero otherwise.
  *
  * Side effects:
  *	None.
@@ -1784,7 +1797,7 @@ TkTextIndexCount(textPtr, indexPtr1, indexPtr2, type)
  *---------------------------------------------------------------------------
  */
 
-void
+int
 TkTextIndexBackBytes(textPtr, srcPtr, byteCount, dstPtr)
     CONST TkText *textPtr;
     CONST TkTextIndex *srcPtr;	/* Source index. */
@@ -1796,8 +1809,7 @@ TkTextIndexBackBytes(textPtr, srcPtr, byteCount, dstPtr)
     int lineIndex;
 
     if (byteCount < 0) {
-	TkTextIndexForwBytes(textPtr, srcPtr, -byteCount, dstPtr);
-	return;
+	return TkTextIndexForwBytes(textPtr, srcPtr, -byteCount, dstPtr);
     }
 
     *dstPtr = *srcPtr;
@@ -1814,7 +1826,7 @@ TkTextIndexBackBytes(textPtr, srcPtr, byteCount, dstPtr)
 	}
 	if (lineIndex == 0) {
 	    dstPtr->byteIndex = 0;
-	    return;
+	    return 1;
 	}
 	lineIndex--;
 	dstPtr->linePtr = TkBTreeFindLine(dstPtr->tree, textPtr, lineIndex);
@@ -1828,6 +1840,7 @@ TkTextIndexBackBytes(textPtr, srcPtr, byteCount, dstPtr)
 	    dstPtr->byteIndex += segPtr->size;
 	}
     }
+    return 0;
 }
 
 /*
@@ -1895,7 +1908,16 @@ TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
 	segPtr = infoPtr->segPtr;
 	segSize -= infoPtr->segOffset;
     } else {
-	for (segPtr = dstPtr->linePtr->segPtr; ; segPtr = segPtr->nextPtr) {
+	TkTextLine *linePtr = dstPtr->linePtr;
+	for (segPtr = linePtr->segPtr; ; segPtr = segPtr->nextPtr) {
+	    if (segPtr == NULL) {
+		/* 
+		 * Two logical lines merged into one display line 
+		 * through eliding of a newline
+		 */
+		linePtr = TkBTreeNextLine(NULL, linePtr);
+		segPtr = linePtr->segPtr;
+	    }
 	    if (segSize <= segPtr->size) {
 		break;
 	    }
@@ -1967,7 +1989,7 @@ TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
 		for (p = end; ; p = Tcl_UtfPrev(p, start)) {
 		    if (charCount == 0) {
 			dstPtr->byteIndex -= (end - p);
-			goto backwadCharDone;
+			goto backwardCharDone;
 		    }
 		    if (p == start) {
 			break;
@@ -1978,7 +2000,7 @@ TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
 		if (type & COUNT_INDICES) {
 		    if (charCount <= segSize) {
 			dstPtr->byteIndex -= charCount;
-			goto backwadCharDone;
+			goto backwardCharDone;
 		    }
 		    charCount -= segSize;
 		}
@@ -2009,7 +2031,7 @@ TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
 	}
 	if (lineIndex == 0) {
 	    dstPtr->byteIndex = 0;
-	    goto backwadCharDone;
+	    goto backwardCharDone;
 	}
 	lineIndex--;
 	dstPtr->linePtr = TkBTreeFindLine(dstPtr->tree, textPtr, lineIndex);
@@ -2026,7 +2048,7 @@ TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
 	segPtr = oldPtr;
 	segSize = segPtr->size;
     }
-  backwadCharDone:
+  backwardCharDone:
     if (infoPtr != NULL) {
 	TkTextFreeElideInfo(infoPtr);
 	ckfree((char*) infoPtr);