1 files changed, 223 insertions, 230 deletions

diff --git a/generic/tkTextDisp.c b/generic/tkTextDisp.c
index 89da5e4..ac6f138 100644
--- a/generic/tkTextDisp.c
+++ b/generic/tkTextDisp.c
@@ -12,7 +12,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.70 2008/10/17 23:18:37 nijtmans Exp $
+ * RCS: @(#) $Id: tkTextDisp.c,v 1.71 2008/11/08 18:44:40 dkf Exp $
  */
 
 #include "tkInt.h"
@@ -446,6 +446,7 @@ typedef struct BaseCharInfo {
 				 * LayoutDLine(). */
 } BaseCharInfo;
 
+/* TODO: Thread safety */
 static TkTextDispChunk *baseCharChunkPtr = NULL;
 
 #endif /* TK_LAYOUT_WITH_BASE_CHUNKS */
@@ -661,10 +662,10 @@ TkTextCreateDInfo(
 
     textPtr->refCount++;
     dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(0,
-	    AsyncUpdateLineMetrics, (ClientData) textPtr);
+	    AsyncUpdateLineMetrics, textPtr);
     textPtr->refCount++;
     dInfoPtr->scrollbarTimer = Tcl_CreateTimerHandler(200,
-	    AsyncUpdateYScrollbar, (ClientData) textPtr);
+	    AsyncUpdateYScrollbar, textPtr);
 
     textPtr->dInfoPtr = dInfoPtr;
 }
@@ -706,7 +707,7 @@ TkTextFreeDInfo(
     }
     Tk_FreeGC(textPtr->display, dInfoPtr->scrollGC);
     if (dInfoPtr->flags & REDRAW_PENDING) {
-	Tcl_CancelIdleCall(DisplayText, (ClientData) textPtr);
+	Tcl_CancelIdleCall(DisplayText, textPtr);
     }
     if (dInfoPtr->lineUpdateTimer != NULL) {
 	Tcl_DeleteTimerHandler(dInfoPtr->lineUpdateTimer);
@@ -1265,14 +1266,14 @@ LayoutDLine(
 	     */
 
 	    TkTextLine *linePtr = TkBTreeNextLine(NULL, curIndex.linePtr);
-	    if (linePtr != NULL) {
-		dlPtr->logicalLinesMerged++;
-		curIndex.byteIndex = 0;
-		curIndex.linePtr = linePtr;
-		segPtr = curIndex.linePtr->segPtr;
-	    } else {
+	    if (linePtr == NULL) {
 		break;
 	    }
+
+	    dlPtr->logicalLinesMerged++;
+	    curIndex.byteIndex = 0;
+	    curIndex.linePtr = linePtr;
+	    segPtr = curIndex.linePtr->segPtr;
 	}
     }
 
@@ -1459,7 +1460,7 @@ LayoutDLine(
 
 	    code = 1;
 	} else {
-	    code = (*segPtr->typePtr->layoutProc)(textPtr, &curIndex, segPtr,
+	    code = segPtr->typePtr->layoutProc(textPtr, &curIndex, segPtr,
 		    byteOffset, maxX-tabSize, maxBytes, noCharsYet, wrapMode,
 		    chunkPtr);
 	}
@@ -1611,18 +1612,18 @@ LayoutDLine(
 	    FreeStyle(textPtr, chunkPtr->stylePtr);
 	    breakChunkPtr->nextPtr = chunkPtr->nextPtr;
 	    if (chunkPtr->undisplayProc != NULL) {
-		(*chunkPtr->undisplayProc)(textPtr, chunkPtr);
+		chunkPtr->undisplayProc(textPtr, chunkPtr);
 	    }
 	    ckfree((char *) chunkPtr);
 	}
 	if (breakByteOffset != breakChunkPtr->numBytes) {
 	    if (breakChunkPtr->undisplayProc != NULL) {
-		(*breakChunkPtr->undisplayProc)(textPtr, breakChunkPtr);
+		breakChunkPtr->undisplayProc(textPtr, breakChunkPtr);
 	    }
 	    segPtr = TkTextIndexToSeg(&breakIndex, &byteOffset);
-	    (*segPtr->typePtr->layoutProc)(textPtr, &breakIndex,
-		    segPtr, byteOffset, maxX, breakByteOffset, 0,
-		    wrapMode, breakChunkPtr);
+	    segPtr->typePtr->layoutProc(textPtr, &breakIndex, segPtr,
+		    byteOffset, maxX, breakByteOffset, 0, wrapMode,
+		    breakChunkPtr);
 #if TK_LAYOUT_WITH_BASE_CHUNKS
 	    FinalizeBaseChunk(NULL);
 #endif /* TK_LAYOUT_WITH_BASE_CHUNKS */
@@ -2306,7 +2307,7 @@ FreeDLines(
 	for (chunkPtr = firstPtr->chunkPtr; chunkPtr != NULL;
 		chunkPtr = nextChunkPtr) {
 	    if (chunkPtr->undisplayProc != NULL) {
-		(*chunkPtr->undisplayProc)(textPtr, chunkPtr);
+		chunkPtr->undisplayProc(textPtr, chunkPtr);
 	    }
 	    FreeStyle(textPtr, chunkPtr->stylePtr);
 	    nextChunkPtr = chunkPtr->nextPtr;
@@ -2404,7 +2405,7 @@ DisplayDLine(
 	    if (chunkPtr->displayProc == TkTextInsertDisplayProc) {
 		int x = chunkPtr->x + dInfoPtr->x - dInfoPtr->curXPixelOffset;
 
-		(*chunkPtr->displayProc)(textPtr, chunkPtr, x,
+		chunkPtr->displayProc(textPtr, chunkPtr, x,
 			y + dlPtr->spaceAbove,
 			dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow,
 			dlPtr->baseline - dlPtr->spaceAbove, display, pixmap,
@@ -2452,7 +2453,7 @@ DisplayDLine(
 
 		x = -chunkPtr->width;
 	    }
-	    (*chunkPtr->displayProc)(textPtr, chunkPtr, x,
+	    chunkPtr->displayProc(textPtr, chunkPtr, x,
 		    y + dlPtr->spaceAbove, dlPtr->height - dlPtr->spaceAbove -
 		    dlPtr->spaceBelow, dlPtr->baseline - dlPtr->spaceAbove,
 		    display, pixmap, dlPtr->y + dlPtr->spaceAbove);
@@ -2878,7 +2879,7 @@ static void
 AsyncUpdateLineMetrics(
     ClientData clientData)	/* Information about widget. */
 {
-    register TkText *textPtr = (TkText *) clientData;
+    register TkText *textPtr = clientData;
     TextDInfo *dInfoPtr = textPtr->dInfoPtr;
     int lineNum;
 
@@ -2948,7 +2949,7 @@ AsyncUpdateLineMetrics(
      */
 
     dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(1,
-	    AsyncUpdateLineMetrics, (ClientData) textPtr);
+	    AsyncUpdateLineMetrics, textPtr);
 }
 
 /*
@@ -3049,86 +3050,82 @@ TkTextUpdateLineMetrics(
 	     */
 
 	    if (TkBTreeLinePixelEpoch(textPtr, linePtr)
-		!= textPtr->dInfoPtr->lineMetricUpdateEpoch) {
-		if (doThisMuch == -1) {
-		    count += 8 * TkTextUpdateOneLine(textPtr, linePtr, 0,
-			    NULL, 0);
-		} else {
-		    TkTextIndex index;
-		    TkTextIndex *indexPtr;
-		    int pixelHeight;
+		    == textPtr->dInfoPtr->lineMetricUpdateEpoch) {
+		/*
+		 * This line is already up to date. That means there's nothing
+		 * to do here.
+		 */
+	    } else if (doThisMuch == -1) {
+		count += 8 * TkTextUpdateOneLine(textPtr, linePtr, 0,NULL,0);
+	    } else {
+		TkTextIndex index;
+		TkTextIndex *indexPtr;
+		int pixelHeight;
 
+		/*
+		 * If the metric epoch is the same as the widget's epoch, then
+		 * we know that indexPtrs are still valid, and if the cached
+		 * metricIndex (if any) is for the same line as we wish to
+		 * examine, then we are looking at a long line wrapped many
+		 * times, which we will examine in pieces.
+		 */
+
+		if (textPtr->dInfoPtr->metricEpoch ==
+			textPtr->sharedTextPtr->stateEpoch &&
+			textPtr->dInfoPtr->metricIndex.linePtr==linePtr) {
+		    indexPtr = &textPtr->dInfoPtr->metricIndex;
+		    pixelHeight = textPtr->dInfoPtr->metricPixelHeight;
+		} else {
 		    /*
-		     * If the metric epoch is the same as the widget's epoch,
-		     * then we know that indexPtrs are still valid, and if the
-		     * cached metricIndex (if any) is for the same line as we
-		     * wish to examine, then we are looking at a long line
-		     * wrapped many times, which we will examine in pieces.
+		     * We must reset the partial line height calculation data
+		     * here, so we don't use it when it is out of date.
 		     */
 
-		    if (textPtr->dInfoPtr->metricEpoch ==
-			    textPtr->sharedTextPtr->stateEpoch &&
-			    textPtr->dInfoPtr->metricIndex.linePtr==linePtr) {
-			indexPtr = &textPtr->dInfoPtr->metricIndex;
-			pixelHeight = textPtr->dInfoPtr->metricPixelHeight;
-		    } else {
-			/*
-			 * We must reset the partial line height calculation
-			 * data here, so we don't use it when it is out of
-			 * date.
-			 */
+		    textPtr->dInfoPtr->metricEpoch = -1;
+		    index.tree = textPtr->sharedTextPtr->tree;
+		    index.linePtr = linePtr;
+		    index.byteIndex = 0;
+		    index.textPtr = NULL;
+		    indexPtr = &index;
+		    pixelHeight = 0;
+		}
 
-			textPtr->dInfoPtr->metricEpoch = -1;
-			index.tree = textPtr->sharedTextPtr->tree;
-			index.linePtr = linePtr;
-			index.byteIndex = 0;
-			index.textPtr = NULL;
-			indexPtr = &index;
-			pixelHeight = 0;
-		    }
+		/*
+		 * Update the line and update the counter, counting 8 for each
+		 * display line we actually re-layout.
+		 */
 
+		count += 8 * TkTextUpdateOneLine(textPtr, linePtr,
+			pixelHeight, indexPtr, 1);
+
+		if (indexPtr->linePtr == linePtr) {
 		    /*
-		     * Update the line and update the counter, counting 8 for
-		     * each display line we actually re-layout.
+		     * We didn't complete the logical line, because it
+		     * produced very many display lines, which must be because
+		     * it must be a long line wrapped many times. So we must
+		     * cache as far as we got for next time around.
 		     */
 
-		    count += 8 * TkTextUpdateOneLine(textPtr, linePtr,
-			    pixelHeight, indexPtr, 1);
-
-		    if (indexPtr->linePtr == linePtr) {
-			/*
-			 * We didn't complete the logical line, because it
-			 * produced very many display lines - it must be a
-			 * long line wrapped many times. So we must cache as
-			 * far as we got for next time around.
-			 */
-
-			if (pixelHeight == 0) {
-			    /*
-			     * These have already been stored, unless we just
-			     * started the new line.
-			     */
-
-			    textPtr->dInfoPtr->metricIndex = index;
-			    textPtr->dInfoPtr->metricEpoch =
-				    textPtr->sharedTextPtr->stateEpoch;
-			}
-			textPtr->dInfoPtr->metricPixelHeight =
-				TkBTreeLinePixelCount(textPtr, linePtr);
-			break;
-		    } else {
+		    if (pixelHeight == 0) {
 			/*
-			 * We're done with this long line.
+			 * These have already been stored, unless we just
+			 * started the new line.
 			 */
 
-			textPtr->dInfoPtr->metricEpoch = -1;
+			textPtr->dInfoPtr->metricIndex = index;
+			textPtr->dInfoPtr->metricEpoch =
+				textPtr->sharedTextPtr->stateEpoch;
 		    }
+		    textPtr->dInfoPtr->metricPixelHeight =
+			    TkBTreeLinePixelCount(textPtr, linePtr);
+		    break;
 		}
-	    } else {
+
 		/*
-		 * This line is already up to date. That means there's nothing
-		 * to do here.
+		 * We're done with this long line.
 		 */
+
+		textPtr->dInfoPtr->metricEpoch = -1;
 	    }
 	} else {
 	    /*
@@ -3329,7 +3326,7 @@ TextInvalidateLineMetrics(
     if (dInfoPtr->lineUpdateTimer == NULL) {
 	textPtr->refCount++;
 	dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(1,
-		AsyncUpdateLineMetrics, (ClientData) textPtr);
+		AsyncUpdateLineMetrics, textPtr);
     }
 }
 
@@ -3379,6 +3376,8 @@ TkTextFindDisplayLineEnd(
 				 * of the original index within its display
 				 * line. */
 {
+    TkTextIndex index;
+
     if (!end && indexPtr->byteIndex == 0) {
 	/*
 	 * Nothing to do.
@@ -3388,95 +3387,93 @@ TkTextFindDisplayLineEnd(
 	    *xOffset = 0;
 	}
 	return;
-    } else {
-	TkTextIndex index = *indexPtr;
-
-	index.byteIndex = 0;
-	index.textPtr = NULL;
-
-	while (1) {
-	    TkTextIndex endOfLastLine;
+    }
 
-	    if (TkTextIndexBackBytes(textPtr, &index, 1, &endOfLastLine)) {
-		/*
-		 * Reached beginning of text.
-		 */
+    index = *indexPtr;
+    index.byteIndex = 0;
+    index.textPtr = NULL;
 
-		break;
-	    }
+    while (1) {
+	TkTextIndex endOfLastLine;
 
-	    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).
-		 */
+	if (TkTextIndexBackBytes(textPtr, &index, 1, &endOfLastLine)) {
+	    /*
+	     * Reached beginning of text.
+	     */
 
-		break;
-	    }
+	    break;
+	}
 
+	if (!TkTextIsElided(textPtr, &endOfLastLine, NULL)) {
 	    /*
-	     * 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.
+	     * The eol is not elided, so 'index' points to the start of a
+	     * display line (as well as logical line).
 	     */
 
-	    index = endOfLastLine;
-	    index.byteIndex = 0;
+	    break;
 	}
 
-	while (1) {
-	    DLine *dlPtr;
-	    int byteCount;
-	    TkTextIndex nextLineStart;
+	/*
+	 * 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.
+	 */
 
-	    dlPtr = LayoutDLine(textPtr, &index);
-	    byteCount = dlPtr->byteCount;
+	index = endOfLastLine;
+	index.byteIndex = 0;
+    }
+
+    while (1) {
+	DLine *dlPtr;
+	int byteCount;
+	TkTextIndex nextLineStart;
 
-	    TkTextIndexForwBytes(textPtr, &index, byteCount, &nextLineStart);
+	dlPtr = LayoutDLine(textPtr, &index);
+	byteCount = dlPtr->byteCount;
+
+	TkTextIndexForwBytes(textPtr, &index, byteCount, &nextLineStart);
+
+	/*
+	 * '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.linePtr == indexPtr->linePtr)
+		&& (index.byteIndex + byteCount > indexPtr->byteIndex))
+		|| (dlPtr->logicalLinesMerged > 0
+		&& TkTextIndexCmp(&nextLineStart, indexPtr) > 0)) {
 	    /*
-	     * '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.
+	     * It's on this display line.
 	     */
 
-	    if (((index.linePtr == indexPtr->linePtr)
-		    && (index.byteIndex + byteCount > indexPtr->byteIndex))
-		    || (dlPtr->logicalLinesMerged > 0
-		    && TkTextIndexCmp(&nextLineStart, indexPtr) > 0)) {
+	    if (xOffset != NULL) {
 		/*
-		 * It's on this display line.
+		 * 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.
 		 */
 
-		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);
-		}
-		if (end) {
-		    /*
-		     * The index we want is one less than the number of bytes
-		     * in the display line.
-		     */
+		*xOffset = DlineXOfIndex(textPtr, dlPtr,
+			indexPtr->byteIndex - dlPtr->index.byteIndex);
+	    }
+	    if (end) {
+		/*
+		 * The index we want is one less than the number of bytes in
+		 * the display line.
+		 */
 
-		    TkTextIndexBackBytes(textPtr, &nextLineStart, 1, indexPtr);
-		} else {
-		    *indexPtr = index;
-		}
-		FreeDLines(textPtr, dlPtr, NULL, DLINE_FREE_TEMP);
-		return;
+		TkTextIndexBackBytes(textPtr, &nextLineStart, 1, indexPtr);
+	    } else {
+		*indexPtr = index;
 	    }
 	    FreeDLines(textPtr, dlPtr, NULL, DLINE_FREE_TEMP);
-	    index = nextLineStart;
+	    return;
 	}
+
+	FreeDLines(textPtr, dlPtr, NULL, DLINE_FREE_TEMP);
+	index = nextLineStart;
     }
 }
 
@@ -3860,7 +3857,7 @@ TkTextUpdateOneLine(
     if (textPtr->dInfoPtr->scrollbarTimer == NULL) {
 	textPtr->refCount++;
 	textPtr->dInfoPtr->scrollbarTimer = Tcl_CreateTimerHandler(200,
-		AsyncUpdateYScrollbar, (ClientData) textPtr);
+		AsyncUpdateYScrollbar, textPtr);
     }
     return displayLines;
 }
@@ -3886,7 +3883,7 @@ static void
 DisplayText(
     ClientData clientData)	/* Information about widget. */
 {
-    register TkText *textPtr = (TkText *) clientData;
+    register TkText *textPtr = clientData;
     TextDInfo *dInfoPtr = textPtr->dInfoPtr;
     register DLine *dlPtr;
     DLine *prevPtr;
@@ -3905,7 +3902,7 @@ DisplayText(
     }
 
     interp = textPtr->interp;
-    Tcl_Preserve((ClientData) interp);
+    Tcl_Preserve(interp);
 
     if (tkTextDebug) {
 	Tcl_SetVar2(interp, "tk_textRelayout", NULL, "", TCL_GLOBAL_ONLY);
@@ -4343,7 +4340,7 @@ DisplayText(
     }
 
   end:
-    Tcl_Release((ClientData) interp);
+    Tcl_Release(interp);
 }
 
 /*
@@ -4372,7 +4369,7 @@ TkTextEventuallyRepick(
     dInfoPtr->flags |= REPICK_NEEDED;
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
 	dInfoPtr->flags |= REDRAW_PENDING;
-	Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr);
+	Tcl_DoWhenIdle(DisplayText, textPtr);
     }
 }
 
@@ -4416,7 +4413,7 @@ TkTextRedrawRegion(
 
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
 	dInfoPtr->flags |= REDRAW_PENDING;
-	Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr);
+	Tcl_DoWhenIdle(DisplayText, textPtr);
     }
     TkDestroyRegion(damageRgn);
 }
@@ -4553,7 +4550,7 @@ TextChanged(
      */
 
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
-	Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr);
+	Tcl_DoWhenIdle(DisplayText, textPtr);
     }
     dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED;
 
@@ -4735,7 +4732,7 @@ TextRedrawTag(
      */
 
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
-	Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr);
+	Tcl_DoWhenIdle(DisplayText, textPtr);
     }
     dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED;
 
@@ -4840,7 +4837,7 @@ TkTextRelayoutWindow(
      */
 
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
-	Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr);
+	Tcl_DoWhenIdle(DisplayText, textPtr);
     }
     dInfoPtr->flags |= REDRAW_PENDING|REDRAW_BORDERS|DINFO_OUT_OF_DATE
 	    |REPICK_NEEDED;
@@ -4935,7 +4932,7 @@ TkTextRelayoutWindow(
 	if (dInfoPtr->lineUpdateTimer == NULL) {
 	    textPtr->refCount++;
 	    dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(1,
-		    AsyncUpdateLineMetrics, (ClientData) textPtr);
+		    AsyncUpdateLineMetrics, textPtr);
 	}
     }
 }
@@ -5119,7 +5116,7 @@ TkTextSetYView(
 
   scheduleUpdate:
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
-	Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr);
+	Tcl_DoWhenIdle(DisplayText, textPtr);
     }
     dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED;
 }
@@ -5385,7 +5382,7 @@ TkTextSeeCmd(
      */
 
     if (chunkPtr != NULL) {
-	(*chunkPtr->bboxProc)(textPtr, chunkPtr, byteCount,
+	chunkPtr->bboxProc(textPtr, chunkPtr, byteCount,
 		dlPtr->y + dlPtr->spaceAbove,
 		dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow,
 		dlPtr->baseline - dlPtr->spaceAbove, &x, &y, &width,
@@ -5399,22 +5396,20 @@ TkTextSeeCmd(
 		dInfoPtr->newXPixelOffset -= ((-delta) );
 	    }
 	} else {
-	    delta -= (lineWidth - width);
-	    if (delta > 0) {
-		if (delta > oneThird) {
-		    dInfoPtr->newXPixelOffset = (x - lineWidth/2);
-		} else {
-		    dInfoPtr->newXPixelOffset += (delta );
-		}
-	    } else {
+	    delta -= lineWidth - width;
+	    if (delta <= 0) {
 		return TCL_OK;
+	    } else if (delta > oneThird) {
+		dInfoPtr->newXPixelOffset = (x - lineWidth/2);
+	    } else {
+		dInfoPtr->newXPixelOffset += (delta );
 	    }
 	}
     }
     dInfoPtr->flags |= DINFO_OUT_OF_DATE;
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
 	dInfoPtr->flags |= REDRAW_PENDING;
-	Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr);
+	Tcl_DoWhenIdle(DisplayText, textPtr);
     }
     return TCL_OK;
 }
@@ -5495,7 +5490,7 @@ TkTextXviewCmd(
     dInfoPtr->flags |= DINFO_OUT_OF_DATE;
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
 	dInfoPtr->flags |= REDRAW_PENDING;
-	Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr);
+	Tcl_DoWhenIdle(DisplayText, textPtr);
     }
     return TCL_OK;
 }
@@ -5580,7 +5575,7 @@ YScrollByPixels(
 	return;
     }
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
-	Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr);
+	Tcl_DoWhenIdle(DisplayText, textPtr);
     }
     dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED;
 }
@@ -5697,7 +5692,7 @@ YScrollByLines(
 
   scheduleUpdate:
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
-	Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr);
+	Tcl_DoWhenIdle(DisplayText, textPtr);
     }
     dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED;
 }
@@ -5977,7 +5972,7 @@ TkTextScanCmd(
 	dInfoPtr->flags |= DINFO_OUT_OF_DATE;
 	if (!(dInfoPtr->flags & REDRAW_PENDING)) {
 	    dInfoPtr->flags |= REDRAW_PENDING;
-	    Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr);
+	    Tcl_DoWhenIdle(DisplayText, textPtr);
 	}
     } else if (c=='m' && strncmp(Tcl_GetString(objv[2]), "mark", length)==0) {
 	dInfoPtr->scanMarkXPixel = dInfoPtr->newXPixelOffset;
@@ -6190,9 +6185,8 @@ GetYPixelCount(
 		notFirst = 1;
 	    }
 	    break;
-	} else {
-	    dlPtr = dlPtr->nextPtr;
 	}
+	dlPtr = dlPtr->nextPtr;
     } while (dlPtr->index.linePtr == linePtr);
 
     return count;
@@ -6378,7 +6372,7 @@ static void
 AsyncUpdateYScrollbar(
     ClientData clientData)	/* Information about widget. */
 {
-    register TkText *textPtr = (TkText *) clientData;
+    register TkText *textPtr = clientData;
 
     textPtr->dInfoPtr->scrollbarTimer = NULL;
 
@@ -6543,25 +6537,26 @@ TkTextPixelIndex(
 	}
 	*indexPtr = textPtr->topIndex;
 	return;
-    } else {
-	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. Use
-		 * the last character on the last line.
-		 */
+    }
+    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. Use the
+	     * last character on the last line.
+	     */
 
-		x = dInfoPtr->maxX - 1;
-		nearby = 1;
-		break;
-	    }
+	    x = dInfoPtr->maxX - 1;
+	    nearby = 1;
+	    break;
 	}
-	if (dlPtr->chunkPtr == NULL) dlPtr = validDlPtr;
+    }
+    if (dlPtr->chunkPtr == NULL) {
+	dlPtr = validDlPtr;
     }
 
     if (nearest != NULL) {
@@ -6654,7 +6649,7 @@ DlineIndexOfX(
      */
 
     if (chunkPtr->numBytes > 1) {
-	indexPtr->byteIndex += (*chunkPtr->measureProc)(chunkPtr, x);
+	indexPtr->byteIndex += chunkPtr->measureProc(chunkPtr, x);
     }
 }
 
@@ -6742,15 +6737,14 @@ DlineXOfIndex(
 	if (byteIndex < chunkPtr->numBytes) {
 	    int y, width, height;
 
-	    (*chunkPtr->bboxProc)(textPtr, chunkPtr, byteIndex,
+	    chunkPtr->bboxProc(textPtr, 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;
 	}
+	byteIndex -= chunkPtr->numBytes;
 	if (chunkPtr->nextPtr == NULL || byteIndex == 0) {
 	    x = chunkPtr->x + chunkPtr->width;
 	    break;
@@ -6838,7 +6832,7 @@ TkTextIndexBbox(
      * coordinate on the screen. Translate it to reflect horizontal scrolling.
      */
 
-    (*chunkPtr->bboxProc)(textPtr, chunkPtr, byteIndex,
+    chunkPtr->bboxProc(textPtr, chunkPtr, byteIndex,
 	    dlPtr->y + dlPtr->spaceAbove,
 	    dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow,
 	    dlPtr->baseline - dlPtr->spaceAbove, xPtr, yPtr, widthPtr,
@@ -7079,7 +7073,7 @@ TkTextCharLayoutProc(
 
 	ciPtr = &bciPtr->ci;
     } else {
-	bciPtr = (BaseCharInfo *) baseCharChunkPtr->clientData;
+	bciPtr = baseCharChunkPtr->clientData;
 	ciPtr = (CharInfo *) ckalloc(sizeof(CharInfo));
 	baseString = &bciPtr->baseChars;
     }
@@ -7087,7 +7081,7 @@ TkTextCharLayoutProc(
     lineOffset = Tcl_DStringLength(baseString);
     line = Tcl_DStringAppend(baseString,p,maxBytes);
 
-    chunkPtr->clientData = (ClientData) ciPtr;
+    chunkPtr->clientData = ciPtr;
     ciPtr->baseChunkPtr = baseCharChunkPtr;
     ciPtr->baseOffset = lineOffset;
     ciPtr->chars = NULL;
@@ -7171,7 +7165,7 @@ TkTextCharLayoutProc(
 #if !TK_LAYOUT_WITH_BASE_CHUNKS
     ciPtr = (CharInfo *)
 	    ckalloc((unsigned) bytesThatFit + Tk_Offset(CharInfo, chars) + 1);
-    chunkPtr->clientData = (ClientData) ciPtr;
+    chunkPtr->clientData = ciPtr;
     memcpy(ciPtr->chars, p, (unsigned) bytesThatFit);
 #endif /* TK_LAYOUT_WITH_BASE_CHUNKS */
 
@@ -7273,7 +7267,7 @@ CharChunkMeasureChars(
 				 * here. */
 {
     Tk_Font tkfont = chunkPtr->stylePtr->sValuePtr->tkfont;
-    CharInfo *ciPtr = (CharInfo *) chunkPtr->clientData;
+    CharInfo *ciPtr = chunkPtr->clientData;
 
 #if !TK_LAYOUT_WITH_BASE_CHUNKS
     if (chars == NULL) {
@@ -7362,7 +7356,7 @@ CharDisplayProc(
     int screenY)		/* Y-coordinate in text window that
 				 * corresponds to y. */
 {
-    CharInfo *ciPtr = (CharInfo *) chunkPtr->clientData;
+    CharInfo *ciPtr = chunkPtr->clientData;
     const char *string;
     TextStyle *stylePtr;
     StyleValues *sValuePtr;
@@ -7380,7 +7374,7 @@ CharDisplayProc(
     }
 
 #if TK_DRAW_IN_CONTEXT
-    bciPtr = (BaseCharInfo *) ciPtr->baseChunkPtr->clientData;
+    bciPtr = ciPtr->baseChunkPtr->clientData;
     numBytes = Tcl_DStringLength(&bciPtr->baseChars);
     string = Tcl_DStringValue(&bciPtr->baseChars);
 
@@ -7513,7 +7507,7 @@ CharUndisplayProc(
     TkText *textPtr,		/* Overall information about text widget. */
     TkTextDispChunk *chunkPtr)	/* Chunk that is about to be freed. */
 {
-    CharInfo *ciPtr = (CharInfo *) chunkPtr->clientData;
+    CharInfo *ciPtr = chunkPtr->clientData;
 
     if (ciPtr) {
 #if TK_LAYOUT_WITH_BASE_CHUNKS
@@ -7616,7 +7610,7 @@ CharBboxProc(
     int *heightPtr)		/* Gets filled in with height of character, in
 				 * pixels. */
 {
-    CharInfo *ciPtr = (CharInfo *) chunkPtr->clientData;
+    CharInfo *ciPtr = chunkPtr->clientData;
     int maxX;
 
     maxX = chunkPtr->width + chunkPtr->x;
@@ -7779,7 +7773,7 @@ AdjustForTab(
 	if (chunkPtr2->displayProc != CharDisplayProc) {
 	    continue;
 	}
-	ciPtr = (CharInfo *) chunkPtr2->clientData;
+	ciPtr = chunkPtr2->clientData;
 	for (p = ciPtr->chars, i = 0; i < ciPtr->numBytes; p++, i++) {
 	    if (isdigit(UCHAR(*p))) {
 		gotDigit = 1;
@@ -7800,23 +7794,23 @@ AdjustForTab(
     if (decimalChunkPtr != NULL) {
 	int curX;
 
-	ciPtr = (CharInfo *) decimalChunkPtr->clientData;
+	ciPtr = decimalChunkPtr->clientData;
 	CharChunkMeasureChars(decimalChunkPtr, NULL, 0, 0, decimal,
 		decimalChunkPtr->x, -1, 0, &curX);
 	desired = tabX - (curX - x);
 	goto update;
-    } else {
-	/*
-	 * There wasn't a decimal point. Right justify the text.
-	 */
+    }
 
-	width = 0;
-	for (chunkPtr2 = chunkPtr->nextPtr; chunkPtr2 != NULL;
-		chunkPtr2 = chunkPtr2->nextPtr) {
-	    width += chunkPtr2->width;
-	}
-	desired = tabX - width;
+    /*
+     * There wasn't a decimal point. Right justify the text.
+     */
+
+    width = 0;
+    for (chunkPtr2 = chunkPtr->nextPtr; chunkPtr2 != NULL;
+	    chunkPtr2 = chunkPtr2->nextPtr) {
+	width += chunkPtr2->width;
     }
+    desired = tabX - width;
 
     /*
      * Shift all of the chunks to the right so that the left edge is at the
@@ -8116,11 +8110,10 @@ MeasureChars(
 	    break;
 	}
 	if (special < end) {
-	    if (ch == '\t') {
-		start++;
-	    } else {
+	    if (ch != '\t') {
 		break;
 	    }
+	    start++;
 	}
     }
 
@@ -8280,7 +8273,7 @@ FinalizeBaseChunk(
 	if (chunkPtr->displayProc != CharDisplayProc) {
 	    continue;
 	}
-	ciPtr = (CharInfo *)chunkPtr->clientData;
+	ciPtr = chunkPtr->clientData;
 	if (ciPtr->baseChunkPtr != baseCharChunkPtr) {
 	    break;
 	}
@@ -8297,7 +8290,7 @@ FinalizeBaseChunk(
     }
 
     if (addChunkPtr != NULL) {
-	ciPtr = (CharInfo *)addChunkPtr->clientData;
+	ciPtr = addChunkPtr->clientData;
 	ciPtr->chars = baseChars + ciPtr->baseOffset;
 
 #if TK_DRAW_IN_CONTEXT
@@ -8348,7 +8341,7 @@ FreeBaseChunk(
 	if (chunkPtr->undisplayProc != CharUndisplayProc) {
 	    continue;
 	}
-	ciPtr = (CharInfo *) chunkPtr->clientData;
+	ciPtr = chunkPtr->clientData;
 	if (ciPtr->baseChunkPtr != baseChunkPtr) {
 	    break;
 	}
@@ -8466,14 +8459,14 @@ RemoveFromBaseChunk(
      * Reinstitute this base chunk for re-layout.
      */
 
-    ciPtr = (CharInfo *) chunkPtr->clientData;
+    ciPtr = chunkPtr->clientData;
     baseCharChunkPtr = ciPtr->baseChunkPtr;
 
     /*
      * Remove the chunk data from the base chunk data.
      */
 
-    bciPtr = (BaseCharInfo *) baseCharChunkPtr->clientData;
+    bciPtr = baseCharChunkPtr->clientData;
 
     if ((ciPtr->baseOffset + ciPtr->numBytes)
 	    != Tcl_DStringLength(&bciPtr->baseChars)) {