Getting more systematic about style

1 files changed, 2313 insertions, 2267 deletions

diff --git a/generic/tkTextDisp.c b/generic/tkTextDisp.c
index 6e6da31..af07711 100644
--- a/generic/tkTextDisp.c
+++ b/generic/tkTextDisp.c
@@ -1,19 +1,18 @@
-/* 
+/*
  * tkTextDisp.c --
  *
- *	This module provides facilities to display text widgets.  It is
- *	the only place where information is kept about the screen layout
- *	of text widgets.  (Well, strictly, each TkTextLine and B-tree
- *	node caches its last observed pixel height, but that information
- *	originates here).
+ *	This module provides facilities to display text widgets. It is the
+ *	only place where information is kept about the screen layout of text
+ *	widgets. (Well, strictly, each TkTextLine and B-tree node caches its
+ *	last observed pixel height, but that information originates here).
  *
  * Copyright (c) 1992-1994 The Regents of the University of California.
  * Copyright (c) 1994-1997 Sun Microsystems, Inc.
  *
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * 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.50 2005/05/13 13:46:12 vincentdarley Exp $
+ * RCS: @(#) $Id: tkTextDisp.c,v 1.51 2005/07/25 23:56:54 dkf Exp $
  */
 
 #include "tkPort.h"
@@ -27,56 +26,52 @@
 /*
  * "Calculations of line pixel heights and the size of the vertical
  * scrollbar."
- * 
+ *
  * Given that tag, font and elide changes can happen to large numbers of
- * diverse chunks in a text widget containing megabytes of text, it is
- * not possible to recalculate all affected height information
- * immediately any such change takes place and maintain a responsive
- * user-experience.  Yet, for an accurate vertical scrollbar to be
- * drawn, we must know the total number of vertical pixels shown on
- * display versus the number available to be displayed.
- * 
- * The way the text widget solves this problem is by maintaining cached
- * line pixel heights (in the BTree for each logical line), and having
- * asynchronous timer callbacks (i) to iterate through the logical
- * lines recalculating their heights, and (ii) to recalculate the
- * vertical scrollbar's position and size.
- * 
- * Typically this works well but there are some situations where the
- * overall functional design of this file causes some problems.  These
- * problems can only arise because the calculations used to display
- * lines on screen are not connected to those in the iterating-line-
- * recalculation-process.
- * 
- * The reason for this disconnect is that the display calculations
- * operate in display lines, and the iteration and cache operates in
- * logical lines.  Given that the display calculations both need not
- * contain complete logical lines (at top or bottom of display), and
- * that they do not actually keep track of logical lines (for simplicity
- * of code and historical design), this means a line may be known and
- * drawn with a different pixel height to that which is cached in the
- * BTree, and this might cause some temporary undesirable mismatch
- * between display and the vertical scrollbar.
- * 
- * All such mismatches should be temporary, however, since the
- * asynchronous height calculations will always catch up eventually.
- * 
+ * diverse chunks in a text widget containing megabytes of text, it is not
+ * possible to recalculate all affected height information immediately any
+ * such change takes place and maintain a responsive user-experience. Yet, for
+ * an accurate vertical scrollbar to be drawn, we must know the total number
+ * of vertical pixels shown on display versus the number available to be
+ * displayed.
+ *
+ * The way the text widget solves this problem is by maintaining cached line
+ * pixel heights (in the BTree for each logical line), and having asynchronous
+ * timer callbacks (i) to iterate through the logical lines recalculating
+ * their heights, and (ii) to recalculate the vertical scrollbar's position
+ * and size.
+ *
+ * Typically this works well but there are some situations where the overall
+ * functional design of this file causes some problems. These problems can
+ * only arise because the calculations used to display lines on screen are not
+ * connected to those in the iterating-line- recalculation-process.
+ *
+ * The reason for this disconnect is that the display calculations operate in
+ * display lines, and the iteration and cache operates in logical lines.
+ * Given that the display calculations both need not contain complete logical
+ * lines (at top or bottom of display), and that they do not actually keep
+ * track of logical lines (for simplicity of code and historical design), this
+ * means a line may be known and drawn with a different pixel height to that
+ * which is cached in the BTree, and this might cause some temporary
+ * undesirable mismatch between display and the vertical scrollbar.
+ *
+ * All such mismatches should be temporary, however, since the asynchronous
+ * height calculations will always catch up eventually.
+ *
  * For further details see the comments before and within the following
  * functions below: LayoutDLine, AsyncUpdateLineMetrics, GetYView,
  * GetYPixelCount, TkTextUpdateOneLine, TkTextUpdateLineMetrics.
  *
- * For details of the way in which the BTree keeps track of pixel
- * heights, see tkTextBTree.c.  Basically the BTree maintains two
- * pieces of information: the logical line indices and the pixel
- * height cache.
+ * For details of the way in which the BTree keeps track of pixel heights, see
+ * tkTextBTree.c. Basically the BTree maintains two pieces of information: the
+ * logical line indices and the pixel height cache.
  */
 
 /*
  * The following structure describes how to display a range of characters.
- * The information is generated by scanning all of the tags associated
- * with the characters and combining that with default information for
- * the overall widget.  These structures form the hash keys for
- * dInfoPtr->styleTable.
+ * The information is generated by scanning all of the tags associated with
+ * the characters and combining that with default information for the overall
+ * widget. These structures form the hash keys for dInfoPtr->styleTable.
  */
 
 typedef struct StyleValues {
@@ -84,13 +79,12 @@ typedef struct StyleValues {
 				 * NULL means use widget background. */
     int borderWidth;		/* Width of 3-D border for background. */
     int relief;			/* 3-D relief for background. */
-    Pixmap bgStipple;		/* Stipple bitmap for background.  None
-				 * means draw solid. */
+    Pixmap bgStipple;		/* Stipple bitmap for background. None means
+				 * draw solid. */
     XColor *fgColor;		/* Foreground color for text. */
     Tk_Font tkfont;		/* Font for displaying text. */
     Pixmap fgStipple;		/* Stipple bitmap for text and other
-				 * foreground stuff.   None means draw
-				 * solid.*/
+				 * foreground stuff. None means draw solid.*/
     int justify;		/* Justification style for text. */
     int lMargin1;		/* Left margin, in pixels, for first display
 				 * line of each text line. */
@@ -104,8 +98,8 @@ typedef struct StyleValues {
     int spacing1;		/* Spacing above first dline in text line. */
     int spacing2;		/* Spacing between lines of dline. */
     int spacing3;		/* Spacing below last dline in text line. */
-    TkTextTabArray *tabArrayPtr;/* Locations and types of tab stops (may
-				 * be NULL). */
+    TkTextTabArray *tabArrayPtr;/* Locations and types of tab stops (may be
+				 * NULL). */
     int underline;		/* Non-zero means draw underline underneath
 				 * text. */
     int elide;			/* Zero means draw text, otherwise not */
@@ -116,123 +110,117 @@ typedef struct StyleValues {
 
 /*
  * The following structure extends the StyleValues structure above with
- * graphics contexts used to actually draw the characters.  The entries
- * in dInfoPtr->styleTable point to structures of this type.
+ * graphics contexts used to actually draw the characters. The entries in
+ * dInfoPtr->styleTable point to structures of this type.
  */
 
 typedef struct TextStyle {
     int refCount;		/* Number of times this structure is
 				 * referenced in Chunks. */
-    GC bgGC;			/* Graphics context for background.  None
-				 * means use widget background. */
+    GC bgGC;			/* Graphics context for background. None means
+				 * use widget background. */
     GC fgGC;			/* Graphics context for foreground. */
     StyleValues *sValuePtr;	/* Raw information from which GCs were
 				 * derived. */
-    Tcl_HashEntry *hPtr;	/* Pointer to entry in styleTable.  Used
-				 * to delete entry. */
+    Tcl_HashEntry *hPtr;	/* Pointer to entry in styleTable. Used to
+				 * delete entry. */
 } TextStyle;
 
 /*
- * The following macro determines whether two styles have the same
- * background so that, for example, no beveled border should be drawn
- * between them.
+ * The following macro determines whether two styles have the same background
+ * so that, for example, no beveled border should be drawn between them.
  */
 
 #define SAME_BACKGROUND(s1, s2) \
     (((s1)->sValuePtr->border == (s2)->sValuePtr->border) \
-        && ((s1)->sValuePtr->borderWidth == (s2)->sValuePtr->borderWidth) \
-        && ((s1)->sValuePtr->relief == (s2)->sValuePtr->relief) \
-        && ((s1)->sValuePtr->bgStipple == (s2)->sValuePtr->bgStipple))
+	&& ((s1)->sValuePtr->borderWidth == (s2)->sValuePtr->borderWidth) \
+	&& ((s1)->sValuePtr->relief == (s2)->sValuePtr->relief) \
+	&& ((s1)->sValuePtr->bgStipple == (s2)->sValuePtr->bgStipple))
 
 /*
- * The following macro is used to compare two floating-point numbers
- * to within a certain degree of scale.  Direct comparison fails on
- * processors where the processor and memory representations of FP
- * numbers of a particular precision is different (e.g. Intel)
+ * The following macro is used to compare two floating-point numbers to within
+ * a certain degree of scale. Direct comparison fails on processors where the
+ * processor and memory representations of FP numbers of a particular
+ * precision is different (e.g. Intel)
  */
 
 #define FP_EQUAL_SCALE(double1, double2, scaleFactor) \
     (fabs((double1)-(double2))*((scaleFactor)+1.0) < 0.3)
 
 /*
- * The following structure describes one line of the display, which may
- * be either part or all of one line of the text.
+ * The following structure describes one line of the display, which may be
+ * either part or all of one line of the text.
  */
 
 typedef struct DLine {
-    TkTextIndex index;		/* Identifies first character in text
-				 * that is displayed on this line. */
+    TkTextIndex index;		/* Identifies first character in text that is
+				 * displayed on this line. */
     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). */
-    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).  */
+				 * 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). */
+    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. */
-    int spaceAbove;		/* How much extra space was added to the
-				 * top of the line because of spacing
-				 * options.  This is included in height
-				 * and baseline. */
+    int spaceAbove;		/* How much extra space was added to the top
+				 * of the line because of spacing options.
+				 * This is included in height and baseline. */
     int spaceBelow;		/* How much extra space was added to the
 				 * bottom of the line because of spacing
-				 * options.  This is included in height. */
+				 * options. This is included in height. */
     int length;			/* Total length of line, in pixels. */
-    TkTextDispChunk *chunkPtr;	/* Pointer to first chunk in list of all
-				 * of those that are displayed on this
-				 * line of the screen. */
-    struct DLine *nextPtr;	/* Next in list of all display lines for
-				 * this window.   The list is sorted in
-				 * order from top to bottom.  Note:  the
-				 * next DLine doesn't always correspond
-				 * to the next line of text:  (a) can have
-				 * multiple DLines for one text line, and
-				 * (b) can have gaps where DLine's have been
-				 * deleted because they're out of date. */
+    TkTextDispChunk *chunkPtr;	/* Pointer to first chunk in list of all of
+				 * those that are displayed on this line of
+				 * the screen. */
+    struct DLine *nextPtr;	/* Next in list of all display lines for this
+				 * window. The list is sorted in order from
+				 * top to bottom. Note: the next DLine doesn't
+				 * always correspond to the next line of text:
+				 * (a) can have multiple DLines for one text
+				 * line, and (b) can have gaps where DLine's
+				 * have been deleted because they're out of
+				 * date. */
     int flags;			/* Various flag bits:  see below for values. */
 } DLine;
 
 /*
  * Flag bits for DLine structures:
  *
- * HAS_3D_BORDER -		Non-zero means that at least one of the
- *				chunks in this line has a 3D border, so
- *				it potentially interacts with 3D borders
- *				in neighboring lines (see
- *				DisplayLineBackground).
+ * HAS_3D_BORDER -		Non-zero means that at least one of the chunks
+ *				in this line has a 3D border, so it
+ *				potentially interacts with 3D borders in
+ *				neighboring lines (see DisplayLineBackground).
  * NEW_LAYOUT -			Non-zero means that the line has been
- *				re-layed out since the last time the
- *				display was updated.
- * TOP_LINE -			Non-zero means that this was the top line
+ *				re-layed out since the last time the display
+ *				was updated.
+ * TOP_LINE -			Non-zero means that this was the top line in
  *				in the window the last time that the window
- *				was laid out.  This is important because
- *				a line may be displayed differently if its
- *				at the top or bottom than if it's in the
- *				middle (e.g. beveled edges aren't displayed
- *				for middle lines if the adjacent line has
- *				a similar background).
+ *				was laid out. This is important because a line
+ *				may be displayed differently if its at the top
+ *				or bottom than if it's in the middle
+ *				(e.g. beveled edges aren't displayed for
+ *				middle lines if the adjacent line has a
+ *				similar background).
  * BOTTOM_LINE -		Non-zero means that this was the bottom line
  *				in the window the last time that the window
  *				was laid out.
- * 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.
+ * 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
@@ -246,14 +234,14 @@ typedef struct DLine {
  */
 
 typedef struct TextDInfo {
-    Tcl_HashTable styleTable;	/* Hash table that maps from StyleValues
-				 * 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. */
+    Tcl_HashTable styleTable;	/* Hash table that maps from StyleValues 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
@@ -268,12 +256,12 @@ typedef struct TextDInfo {
 				 * Leaves space for border, etc. */
     int maxX;			/* First x-coordinate to right of available
 				 * space for displaying lines. */
-    int maxY;			/* First y-coordinate below available
-				 * space for displaying lines. */
+    int maxY;			/* First y-coordinate below available space
+				 * for displaying lines. */
     int topOfEof;		/* Top-most pixel (lowest y-value) that has
 				 * been drawn in the appropriate fashion for
 				 * the portion of the window after the last
-				 * line of the text.  This field is used to
+				 * line of the text. This field is used to
 				 * figure out when to redraw part or all of
 				 * the eof field. */
 
@@ -282,29 +270,29 @@ typedef struct TextDInfo {
      */
 
     int newXPixelOffset;	/* Desired x scroll position, measured as the
-				 * number of pixels off-screen to the left 
-				 * for a line with no left margin. */
+				 * number of pixels off-screen to the left for
+				 * a line with no left margin. */
     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
-				 * size).  If there's no wrapping, this will
-				 * be zero. */
+				 * size). If there's no wrapping, this will be
+				 * zero. */
     double xScrollFirst, xScrollLast;
 				/* Most recent values reported to horizontal
-				 * scrollbar;  used to eliminate unnecessary
+				 * scrollbar; used to eliminate unnecessary
 				 * reports. */
     double yScrollFirst, yScrollLast;
 				/* Most recent values reported to vertical
-				 * scrollbar;  used to eliminate unnecessary
+				 * scrollbar; used to eliminate unnecessary
 				 * reports. */
 
     /*
      * The following information is used to implement scanning:
      */
 
-    int scanMarkXPixel;		/* Pixel index of left edge of the window 
-                       		 * when the scan started. */
+    int scanMarkXPixel;		/* Pixel index of left edge of the window when
+				 * the scan started. */
     int scanMarkX;		/* X-position of mouse at time scan started. */
     int scanTotalYScroll;	/* Total scrolling (in screen pixels) that has
 				 * occurred since scanMarkY was set. */
@@ -316,83 +304,80 @@ typedef struct TextDInfo {
 
     int dLinesInvalidated;	/* This value is set to 1 whenever something
 				 * happens that invalidates information in
-				 * DLine structures;  if a redisplay
-				 * is in progress, it will see this and
-				 * abort the redisplay.  This is needed
-				 * because, for example, an embedded window
-				 * could change its size when it is first
-				 * displayed, invalidating the DLine that
-				 * is currently being displayed.  If redisplay
-				 * continues, it will use freed memory and
-				 * could dump core. */
-    int flags;			/* Various flag values:  see below for
+				 * DLine structures; if a redisplay is in
+				 * progress, it will see this and abort the
+				 * redisplay. This is needed because, for
+				 * example, an embedded window could change
+				 * its size when it is first displayed,
+				 * invalidating the DLine that is currently
+				 * being displayed. If redisplay continues, it
+				 * will use freed memory and could dump
+				 * core. */
+    int flags;			/* Various flag values: see below for
 				 * definitions. */
     /*
-     * Information used to handle the asynchronous updating of the
-     * y-scrollbar and the vertical height calculations:
+     * 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 
+    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.  */
-    TkTextIndex metricIndex;    /* If the current metric update line
-                                 * wraps into very many display lines, then
-                                 * this is used to keep track of what
-                                 * index we've got to so far... */
-    int metricPixelHeight;      /* ...and this is for the height
-                                 * calculation so far...*/
-    int metricEpoch;            /* ...and this for the epoch of the
-                                 * partial calculation so it can be
-                                 * cancelled if things change once more.
-                                 * This field will be -1 if there is no
-                                 * long-line calculation in progress, 
-                                 * and take a non-negative value if 
-                                 * there is such a calculation in 
-                                 * progress. */
-    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. */
+    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. */
+    TkTextIndex metricIndex;	/* If the current metric update line wraps
+				 * into very many display lines, then this is
+				 * used to keep track of what index we've got
+				 * to so far... */
+    int metricPixelHeight;	/* ...and this is for the height calculation
+				 * so far...*/
+    int metricEpoch;		/* ...and this for the epoch of the partial
+				 * calculation so it can be cancelled if
+				 * things change once more. This field will be
+				 * -1 if there is no long-line calculation in
+				 * progress, and take a non-negative value if
+				 * there is such a calculation in progress. */
+    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;
 
 /*
- * In TkTextDispChunk structures for character segments, the clientData
- * field points to one of the following structures:
+ * In TkTextDispChunk structures for character segments, the clientData field
+ * points to one of the following structures:
  */
 
 typedef struct CharInfo {
     int numBytes;		/* Number of bytes to display. */
-    char chars[4];		/* UTF characters to display.  Actual size
-				 * will be numBytes, not 4.  THIS MUST BE
-				 * THE LAST FIELD IN THE STRUCTURE. */
+    char chars[4];		/* UTF characters to display. Actual size will
+				 * be numBytes, not 4. THIS MUST BE THE LAST
+				 * FIELD IN THE STRUCTURE. */
 } CharInfo;
 
 /*
  * Flag values for TextDInfo structures:
  *
- * DINFO_OUT_OF_DATE:		Non-zero means that the DLine structures
- *				for this window are partially or completely
- *				out of date and need to be recomputed.
+ * DINFO_OUT_OF_DATE:		Non-zero means that the DLine structures for
+ *				this window are partially or completely out of
+ *				date and need to be recomputed.
  * REDRAW_PENDING:		Means that a when-idle handler has been
  *				scheduled to update the display.
  * REDRAW_BORDERS:		Means window border or pad area has
  *				potentially been damaged and must be redrawn.
- * REPICK_NEEDED:		1 means that the widget has been modified
- *				in a way that could change the current
- *				character (a different character might be
- *				under the mouse cursor now).  Need to
- *				recompute the current character before
- *				the next redisplay.
+ * REPICK_NEEDED:		1 means that the widget has been modified in a
+ *				way that could change the current character (a
+ *				different character might be under the mouse
+ *				cursor now). Need to recompute the current
+ *				character before the next redisplay.
  */
 
 #define DINFO_OUT_OF_DATE	1
@@ -403,41 +388,42 @@ typedef struct CharInfo {
 /*
  * Action values for FreeDLines:
  *
- * DLINE_FREE:		Free the lines, but no need to unlink them
- *                      from the current list of actual display lines.
+ * 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'.
+ * 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
+#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.
+ * The following counters keep statistics about redisplay that can be checked
+ * to see how clever this code is at reducing redisplays.
  */
 
-static int numRedisplays;	    /* Number of calls to DisplayText. */
-static int linesRedrawn;	    /* Number of calls to DisplayDLine. */
-static int numCopies;		    /* Number of calls to XCopyArea
-				     * to copy part of the screen.  */
-static int lineHeightsRecalculated; /* Number of line layouts purely
-                                     * for height calculation purposes.*/
+static int numRedisplays;	/* Number of calls to DisplayText. */
+static int linesRedrawn;	/* Number of calls to DisplayDLine. */
+static int numCopies;		/* Number of calls to XCopyArea to copy part
+				 * of the screen. */
+static int lineHeightsRecalculated;
+				/* Number of line layouts purely for height
+				 * calculation purposes.*/
 /*
- * Forward declarations for procedures defined later in this file:
+ * Forward declarations for functions defined later in this file:
  */
 
 static void		AdjustForTab _ANSI_ARGS_((TkText *textPtr,
 			    TkTextTabArray *tabArrayPtr, int index,
 			    TkTextDispChunk *chunkPtr));
-static void		CharBboxProc _ANSI_ARGS_((TkText *textPtr, 
+static void		CharBboxProc _ANSI_ARGS_((TkText *textPtr,
 			    TkTextDispChunk *chunkPtr,
 			    int index, int y, int lineHeight, int baseline,
 			    int *xPtr, int *yPtr, int *widthPtr,
 			    int *heightPtr));
-static void		CharDisplayProc _ANSI_ARGS_((TkText *textPtr, 
+static void		CharDisplayProc _ANSI_ARGS_((TkText *textPtr,
 			    TkTextDispChunk *chunkPtr,
 			    int x, int y, int height, int baseline,
 			    Display *display, Drawable dst, int screenY));
@@ -447,19 +433,19 @@ static void		CharUndisplayProc _ANSI_ARGS_((TkText *textPtr,
 			    TkTextDispChunk *chunkPtr));
 
 /*
-   Definitions of elided procs.
-   Compiler can't inline these since we use pointers to these functions.
-   ElideDisplayProc, ElideUndisplayProc special-cased for speed,
-   as potentially many elided DLine chunks if large, tag toggle-filled
-   elided region.
-*/
-static void		ElideBboxProc _ANSI_ARGS_((TkText *textPtr, 
+ * Definitions of elided procs. Compiler can't inline these since we use
+ * pointers to these functions. ElideDisplayProc, ElideUndisplayProc
+ * special-cased for speed, as potentially many elided DLine chunks if large,
+ * tag toggle-filled elided region.
+ */
+
+static void		ElideBboxProc _ANSI_ARGS_((TkText *textPtr,
 			    TkTextDispChunk *chunkPtr,
 			    int index, int y, int lineHeight, int baseline,
 			    int *xPtr, int *yPtr, int *widthPtr,
 			    int *heightPtr));
-static int		ElideMeasureProc _ANSI_ARGS_((TkTextDispChunk *chunkPtr,
-			    int x));
+static int		ElideMeasureProc _ANSI_ARGS_((
+			    TkTextDispChunk *chunkPtr, int x));
 
 static void		DisplayDLine _ANSI_ARGS_((TkText *textPtr,
 			    DLine *dlPtr, DLine *prevPtr, Pixmap pixmap));
@@ -478,7 +464,7 @@ 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              GetYPixelCount _ANSI_ARGS_((TkText *textPtr, 
+static int		GetYPixelCount _ANSI_ARGS_((TkText *textPtr,
 			    DLine *dlPtr));
 static DLine *		LayoutDLine _ANSI_ARGS_((TkText *textPtr,
 			    CONST TkTextIndex *indexPtr));
@@ -496,43 +482,43 @@ static void		YScrollByLines _ANSI_ARGS_((TkText *textPtr,
 static void		YScrollByPixels _ANSI_ARGS_((TkText *textPtr,
 			    int offset));
 static int		SizeOfTab _ANSI_ARGS_((TkText *textPtr,
-			    TkTextTabArray *tabArrayPtr, int *indexPtr, 
+			    TkTextTabArray *tabArrayPtr, int *indexPtr,
 			    int x, int maxX));
 static void		TextChanged _ANSI_ARGS_((TkText *textPtr,
-			    CONST TkTextIndex *index1Ptr, 
+			    CONST TkTextIndex *index1Ptr,
 			    CONST TkTextIndex *index2Ptr));
 static void		TextInvalidateRegion _ANSI_ARGS_((TkText *textPtr,
 			    TkRegion region));
 static void		TextRedrawTag _ANSI_ARGS_((TkText *textPtr,
 			    TkTextIndex *index1Ptr, TkTextIndex *index2Ptr,
 			    TkTextTag *tagPtr, int withTag));
-static void             TextInvalidateLineMetrics _ANSI_ARGS_((TkText *textPtr,
+static void		TextInvalidateLineMetrics _ANSI_ARGS_((TkText *textPtr,
 			    TkTextLine *linePtr, int lineCount, int action));
-static int              CalculateDisplayLineHeight _ANSI_ARGS_((
-			    TkText *textPtr, CONST TkTextIndex *indexPtr, 
+static int		CalculateDisplayLineHeight _ANSI_ARGS_((
+			    TkText *textPtr, CONST TkTextIndex *indexPtr,
 			    int *byteCountPtr, int *mergedLinePtr));
-static void             DlineIndexOfX _ANSI_ARGS_((TkText *textPtr, 
+static void		DlineIndexOfX _ANSI_ARGS_((TkText *textPtr,
 			    DLine *dlPtr, int x, TkTextIndex *indexPtr));
-static int              DlineXOfIndex _ANSI_ARGS_((TkText *textPtr, 
+static int		DlineXOfIndex _ANSI_ARGS_((TkText *textPtr,
 			    DLine *dlPtr, int byteIndex));
-static int              TextGetScrollInfoObj _ANSI_ARGS_((Tcl_Interp *interp, 
-			    TkText *textPtr, int objc, 
+static int		TextGetScrollInfoObj _ANSI_ARGS_((Tcl_Interp *interp,
+			    TkText *textPtr, int objc,
 			    Tcl_Obj *CONST objv[], double *dblPtr,
 			    int *intPtr));
-static void	        AsyncUpdateLineMetrics _ANSI_ARGS_((ClientData 
+static void		AsyncUpdateLineMetrics _ANSI_ARGS_((ClientData
 			    clientData));
-static void	        AsyncUpdateYScrollbar _ANSI_ARGS_((ClientData 
+static void		AsyncUpdateYScrollbar _ANSI_ARGS_((ClientData
 			    clientData));
 
 /*
  * Result values returned by TextGetScrollInfoObj:
  */
 
-#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
+#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
 
 
 /*
@@ -540,8 +526,8 @@ static void	        AsyncUpdateYScrollbar _ANSI_ARGS_((ClientData
  *
  * TkTextCreateDInfo --
  *
- *	This procedure is called when a new text widget is created.
- *	Its job is to set up display-related information for the widget.
+ *	This function is called when a new text widget is created. Its job is
+ *	to set up display-related information for the widget.
  *
  * Results:
  *	None.
@@ -589,13 +575,16 @@ TkTextCreateDInfo(textPtr)
     dInfoPtr->metricEpoch = -1;
     dInfoPtr->metricIndex.textPtr = NULL;
     dInfoPtr->metricIndex.linePtr = NULL;
-    
-    /* Add a refCount for each of the idle call-backs */
+
+    /*
+     * Add a refCount for each of the idle call-backs.
+     */
+
     textPtr->refCount++;
-    dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(0, 
+    dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(0,
 	    AsyncUpdateLineMetrics, (ClientData) textPtr);
     textPtr->refCount++;
-    dInfoPtr->scrollbarTimer = Tcl_CreateTimerHandler(200, 
+    dInfoPtr->scrollbarTimer = Tcl_CreateTimerHandler(200,
 	    AsyncUpdateYScrollbar, (ClientData) textPtr);
 
     textPtr->dInfoPtr = dInfoPtr;
@@ -606,7 +595,7 @@ TkTextCreateDInfo(textPtr)
  *
  * TkTextFreeDInfo --
  *
- *	This procedure is called to free up all of the private display
+ *	This function is called to free up all of the private display
  *	information kept by this file for a text widget.
  *
  * Results:
@@ -625,10 +614,10 @@ TkTextFreeDInfo(textPtr)
     register TextDInfo *dInfoPtr = textPtr->dInfoPtr;
 
     /*
-     * Be careful to free up styleTable *after* freeing up all the
-     * DLines, so that the hash table is still intact to free up the
-     * style-related information from the lines.  Once the lines are
-     * all free then styleTable will be empty.
+     * Be careful to free up styleTable *after* freeing up all the DLines, so
+     * that the hash table is still intact to free up the style-related
+     * information from the lines. Once the lines are all free then styleTable
+     * will be empty.
      */
 
     FreeDLines(textPtr, dInfoPtr->dLinePtr, (DLine *) NULL, DLINE_UNLINK);
@@ -658,8 +647,8 @@ TkTextFreeDInfo(textPtr)
  *
  * GetStyle --
  *
- *	This procedure creates all the information needed to display
- *	text at a particular location.
+ *	This function creates all the information needed to display text at a
+ *	particular location.
  *
  * Results:
  *	The return value is a pointer to a TextStyle structure that
@@ -674,8 +663,8 @@ TkTextFreeDInfo(textPtr)
 static TextStyle *
 GetStyle(textPtr, indexPtr)
     TkText *textPtr;		/* Overall information about text widget. */
-    CONST TkTextIndex *indexPtr;/* The character in the text for which
-				 * display information is wanted. */
+    CONST TkTextIndex *indexPtr;/* The character in the text for which display
+				 * information is wanted. */
 {
     TkTextTag **tagPtrs;
     register TkTextTag *tagPtr;
@@ -699,10 +688,9 @@ GetStyle(textPtr, indexPtr)
     int overstrikePrio, tabPrio, wrapPrio;
 
     /*
-     * Find out what tags are present for the character, then compute
-     * a StyleValues structure corresponding to those tags (scan
-     * through all of the tags, saving information for the highest-
-     * priority tag).
+     * Find out what tags are present for the character, then compute a
+     * StyleValues structure corresponding to those tags (scan through all of
+     * the tags, saving information for the highest-priority tag).
      */
 
     tagPtrs = TkBTreeGetTags(indexPtr, textPtr, &numTags);
@@ -723,20 +711,22 @@ GetStyle(textPtr, indexPtr)
     styleValues.tabArrayPtr = textPtr->tabArrayPtr;
     styleValues.wrapMode = textPtr->wrapMode;
     styleValues.elide = 0;
+
     for (i = 0 ; i < numTags; i++) {
 	Tk_3DBorder border;
+
 	tagPtr = tagPtrs[i];
 	border = tagPtr->border;
-	
+
 	/*
-	 * If this is the selection tag, and inactiveSelBorder is NULL
-	 * (the default on Windows and Mac), then we need to skip it if
-	 * we don't have focus.
+	 * If this is the selection tag, and inactiveSelBorder is NULL (the
+	 * default on Windows and Mac), then we need to skip it if we don't
+	 * have focus.
 	 */
 
 	if ((tagPtr == textPtr->selTagPtr) && !(textPtr->flags & GOT_FOCUS)) {
 	    if (textPtr->inactiveSelBorder == NULL) {
-	        continue;
+		continue;
 	    }
 	    border = textPtr->inactiveSelBorder;
 	}
@@ -745,8 +735,8 @@ GetStyle(textPtr, indexPtr)
 	    styleValues.border = border;
 	    borderPrio = tagPtr->priority;
 	}
-	if ((tagPtr->borderWidthPtr != NULL) 
-	        && (Tcl_GetString(tagPtr->borderWidthPtr)[0] != '\0')
+	if ((tagPtr->borderWidthPtr != NULL)
+		&& (Tcl_GetString(tagPtr->borderWidthPtr)[0] != '\0')
 		&& (tagPtr->priority > borderWidthPrio)) {
 	    styleValues.borderWidth = tagPtr->borderWidth;
 	    borderWidthPrio = tagPtr->priority;
@@ -860,7 +850,7 @@ GetStyle(textPtr, indexPtr)
     }
 
     /*
-     * No existing style matched.  Make a new one.
+     * No existing style matched. Make a new one.
      */
 
     stylePtr = (TextStyle *) ckalloc(sizeof(TextStyle));
@@ -899,16 +889,16 @@ GetStyle(textPtr, indexPtr)
  *
  * FreeStyle --
  *
- *	This procedure is called when a TextStyle structure is no longer
- *	needed.  It decrements the reference count and frees up the
- *	space for the style structure if the reference count is 0.
+ *	This function is called when a TextStyle structure is no longer
+ *	needed. It decrements the reference count and frees up the space for
+ *	the style structure if the reference count is 0.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The storage and other resources associated with the style
- *	are freed up if no-one's still using it.
+ *	The storage and other resources associated with the style are freed up
+ *	if no-one's still using it.
  *
  *----------------------------------------------------------------------
  */
@@ -937,32 +927,31 @@ FreeStyle(textPtr, stylePtr)
  *
  * LayoutDLine --
  *
- *	This procedure generates a single DLine structure for a display
- *	line whose leftmost character is given by indexPtr.
- *	
+ *	This function generates a single DLine structure for a display line
+ *	whose leftmost character is given by indexPtr.
+ *
  * Results:
  *	The return value is a pointer to a DLine structure desribing the
- *	display line.  All fields are filled in and correct except for
- *	y and nextPtr.
+ *	display line. All fields are filled in and correct except for y and
+ *	nextPtr.
  *
  * 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.
+ *
+ *	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.
  *
  *----------------------------------------------------------------------
  */
@@ -970,13 +959,14 @@ FreeStyle(textPtr, stylePtr)
 static DLine *
 LayoutDLine(textPtr, indexPtr)
     TkText *textPtr;		/* Overall information about text widget. */
-    CONST TkTextIndex *indexPtr;/* Beginning of display line.  May not
-				 * necessarily point to a character segment. */
+    CONST TkTextIndex *indexPtr;/* Beginning of display line. May not
+				 * necessarily point to a character
+				 * segment. */
 {
     register DLine *dlPtr;		/* New display line. */
     TkTextSegment *segPtr;		/* Current segment in text. */
-    TkTextDispChunk *lastChunkPtr;	/* Last chunk allocated so far
-					 * for line. */
+    TkTextDispChunk *lastChunkPtr;	/* Last chunk allocated so far for
+					 * line. */
     TkTextDispChunk *chunkPtr;		/* Current chunk. */
     TkTextIndex curIndex;
     TkTextDispChunk *breakChunkPtr;	/* Chunk containing best word break
@@ -987,7 +977,8 @@ LayoutDLine(textPtr, indexPtr)
 					 * breakChunkPtr just to right of best
 					 * break point. */
     int noCharsYet;			/* Non-zero means that no characters
-					 * have been placed on the line yet. */
+					 * have been placed on the line
+					 * yet. */
     int justify;			/* How to justify line: taken from
 					 * style for the first character in
 					 * line. */
@@ -995,30 +986,31 @@ LayoutDLine(textPtr, indexPtr)
 					 * margins) due to justification. */
     int rMargin;			/* Right margin width for line. */
     TkWrapMode wrapMode;		/* Wrap mode to use for this line. */
-    int x = 0, maxX = 0;		/* Initializations needed only to
-					 * stop compiler warnings. */
+    int x = 0, maxX = 0;		/* Initializations needed only to stop
+					 * compiler warnings. */
     int wholeLine;			/* Non-zero means this display line
-					 * runs to the end of the text line. */
+					 * runs to the end of the text
+					 * line. */
     int tabIndex;			/* Index of the current tab stop. */
     int gotTab;				/* Non-zero means the current chunk
 					 * contains a tab. */
-    TkTextDispChunk *tabChunkPtr;	/* Pointer to the chunk containing
-					 * the previous tab stop. */
-    int maxBytes;			/* Maximum number of bytes to
-					 * include in this chunk. */
+    TkTextDispChunk *tabChunkPtr;	/* Pointer to the chunk containing the
+					 * previous tab stop. */
+    int maxBytes;			/* Maximum number of bytes to include
+					 * in this chunk. */
     TkTextTabArray *tabArrayPtr;	/* Tab stops for line; taken from
 					 * style for the first character on
 					 * line. */
-    int tabSize;			/* Number of pixels consumed by current
-					 * tab stop. */
+    int tabSize;			/* Number of pixels consumed by
+					 * current tab stop. */
     TkTextDispChunk *lastCharChunkPtr;	/* Pointer to last chunk in display
-					 * lines with numBytes > 0.  Used to
-					 * drop 0-sized chunks from the end
-					 * of the line. */
+					 * lines with numBytes > 0. Used to
+					 * drop 0-sized chunks from the end of
+					 * the line. */
     int byteOffset, ascent, descent, code, elide, elidesize;
     StyleValues *sValuePtr;
-    TkTextElideInfo info;               /* Keep track of elide state */
-    
+    TkTextElideInfo info;		/* Keep track of elide state */
+
     /*
      * Create and initialize a new DLine structure.
      */
@@ -1034,10 +1026,11 @@ LayoutDLine(textPtr, indexPtr)
     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
      */
+
     elide = TkTextIsElided(textPtr, indexPtr, &info);
     if (elide && indexPtr->byteIndex==0) {
 	maxBytes = 0;
@@ -1046,25 +1039,28 @@ LayoutDLine(textPtr, indexPtr)
 		if (elide == 0) {
 		    /*
 		     * We toggled a tag and the elide state changed to
-		     * visible, and we have something of non-zero 
-		     * size.  Therefore we must bail out.
+		     * visible, and we have something of non-zero size.
+		     * Therefore we must bail out.
 		     */
+
 		    break;
 		}
 		maxBytes += segPtr->size;
-		/* 
-		 * Reset tag elide priority, since we're on a new
-		 * character.
+
+		/*
+		 * Reset tag elide priority, since we're on a new character.
 		 */
+
 	    } else if ((segPtr->typePtr == &tkTextToggleOffType)
-		       || (segPtr->typePtr == &tkTextToggleOnType)) {
+		    || (segPtr->typePtr == &tkTextToggleOnType)) {
 		TkTextTag *tagPtr = segPtr->body.toggle.tagPtr;
+
 		/*
-		 * The elide state only changes if this tag is
-		 * either the current highest priority tag
-		 * (and is therefore being toggled off), or it's
-		 * a new tag with higher priority.
+		 * The elide state only changes if this tag is either the
+		 * current highest priority tag (and is therefore being
+		 * toggled off), or it's a new tag with higher priority.
 		 */
+
 		if (tagPtr->elideString != NULL) {
 		    info.tagCnts[tagPtr->priority]++;
 		    if (info.tagCnts[tagPtr->priority] & 1) {
@@ -1072,25 +1068,26 @@ LayoutDLine(textPtr, indexPtr)
 		    }
 		    if (tagPtr->priority >= info.elidePriority) {
 			if (segPtr->typePtr == &tkTextToggleOffType) {
-			    /* 
-			     * If it is being toggled off, and it has
-			     * an elide string, it must actually be the
-			     * current highest priority tag, so this
-			     * check is redundant:
+			    /*
+			     * If it is being toggled off, and it has an elide
+			     * string, it must actually be the current highest
+			     * priority tag, so this check is redundant:
 			     */
+
 			    if (tagPtr->priority != info.elidePriority) {
 				Tcl_Panic("Bad tag priority being toggled off");
 			    }
-			    
-			    /* 
-			     * Find previous elide tag, if any (if not
-			     * then elide will be zero, of course).
+
+			    /*
+			     * Find previous elide tag, if any (if not then
+			     * elide will be zero, of course).
 			     */
+
 			    elide = 0;
 			    while (--info.elidePriority > 0) {
 				if (info.tagCnts[info.elidePriority] & 1) {
 				    elide = info.tagPtrs[info.elidePriority]
-								     ->elide;
+					    ->elide;
 				    break;
 				}
 			    }
@@ -1107,18 +1104,18 @@ LayoutDLine(textPtr, indexPtr)
 	    dlPtr->byteCount = maxBytes;
 	    dlPtr->spaceAbove = dlPtr->spaceBelow = dlPtr->length = 0;
 	    if (dlPtr->index.byteIndex == 0) {
-		/* 
-		 * Elided state goes from beginning to end of 
-		 * an entire logical line.  This means we can
-		 * update the line's pixel height, and bring
-		 * its pixel calculation up to date.
+		/*
+		 * Elided state goes from beginning to end of an entire
+		 * logical line. This means we can update the line's pixel
+		 * height, and bring its pixel calculation up to date.
 		 */
+
 		TkBTreeLinePixelEpoch(textPtr, dlPtr->index.linePtr)
-		  = textPtr->dInfoPtr->lineMetricUpdateEpoch;
+			= textPtr->dInfoPtr->lineMetricUpdateEpoch;
 
-		if (TkBTreeLinePixelCount(textPtr, dlPtr->index.linePtr) != 0) {
-		    TkBTreeAdjustPixelHeight(textPtr, 
-					     dlPtr->index.linePtr, 0, 0);
+		if (TkBTreeLinePixelCount(textPtr,dlPtr->index.linePtr) != 0) {
+		    TkBTreeAdjustPixelHeight(textPtr,
+			    dlPtr->index.linePtr, 0, 0);
 		}
 	    }
 	    TkTextFreeElideInfo(&info);
@@ -1126,12 +1123,11 @@ LayoutDLine(textPtr, indexPtr)
 	}
     }
     TkTextFreeElideInfo(&info);
-    
+
     /*
-     * Each iteration of the loop below creates one TkTextDispChunk for
-     * the new display line.  The line will always have at least one
-     * chunk (for the newline character at the end, if there's nothing
-     * else available).
+     * Each iteration of the loop below creates one TkTextDispChunk for the
+     * new display line. The line will always have at least one chunk (for the
+     * newline character at the end, if there's nothing else available).
      */
 
     curIndex = *indexPtr;
@@ -1149,11 +1145,11 @@ 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).
+     * 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).
      */
 
   connectNextLogicalLine:
@@ -1162,12 +1158,13 @@ LayoutDLine(textPtr, indexPtr)
     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
+	    /*
+	     * Two logical lines merged into one display line through eliding
+	     * of a newline.
 	     */
+
 	    TkTextLine *linePtr = TkBTreeNextLine(NULL, curIndex.linePtr);
 	    if (linePtr != NULL) {
 		dlPtr->logicalLinesMerged++;
@@ -1185,25 +1182,27 @@ LayoutDLine(textPtr, indexPtr)
 	 * 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.  We may wish to redesign the code to
-	 * remove these zero height DLines in the future.
+	 *
+	 * 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. We
+	 * may wish to redesign the code to remove these zero height DLines in
+	 * the future.
 	 */
+
 	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
+		 * If have we have a tag toggle, there is a chance that
+		 * invisibility state changed, so bail out.
 		 */
 	    } else if ((segPtr->typePtr == &tkTextToggleOffType)
 		    || (segPtr->typePtr == &tkTextToggleOnType)) {
@@ -1215,13 +1214,15 @@ LayoutDLine(textPtr, indexPtr)
 
 	    byteOffset = 0;
 	    segPtr = segPtr->nextPtr;
-	    
+
 	    if (segPtr == NULL) {
-		/* 
-		 * Two logical lines merged into one display line 
-		 * through eliding of a newline
+		/*
+		 * 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;
@@ -1229,12 +1230,17 @@ LayoutDLine(textPtr, indexPtr)
 		    goto connectNextLogicalLine;
 		}
 	    }
-	    /* Code no longer needed, now that we allow logical lines
-	     * to merge into a single display line.
+
+	    /*
+	     * 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;
 	}
 
@@ -1251,8 +1257,8 @@ LayoutDLine(textPtr, indexPtr)
 	elide = chunkPtr->stylePtr->sValuePtr->elide;
 
 	/*
-	 * Save style information such as justification and indentation,
-	 * up until the first character is encountered, then retain that
+	 * Save style information such as justification and indentation, up
+	 * until the first character is encountered, then retain that
 	 * information for the rest of the line.
 	 */
 
@@ -1276,8 +1282,8 @@ LayoutDLine(textPtr, indexPtr)
 	}
 
 	/*
-	 * See if there is a tab in the current chunk; if so, only
-	 * layout characters up to (and including) the tab.
+	 * See if there is a tab in the current chunk; if so, only layout
+	 * characters up to (and including) the tab.
 	 */
 
 	gotTab = 0;
@@ -1297,14 +1303,16 @@ LayoutDLine(textPtr, indexPtr)
 	}
 	chunkPtr->x = x;
 	if (elide && maxBytes) {
-	    /* 
-	     * Don't free style here, as other code expects to be able to
-	     * do that.
+	    /*
+	     * Don't free style here, as other code expects to be able to do
+	     * that.
 	     */
-	    /* breakByteOffset =*/ 
+
+	    /* breakByteOffset =*/
 	    chunkPtr->breakIndex = chunkPtr->numBytes = maxBytes;
 	    chunkPtr->width = 0;
-	    chunkPtr->minAscent = chunkPtr->minDescent = chunkPtr->minHeight = 0;
+	    chunkPtr->minAscent = chunkPtr->minDescent
+		    = chunkPtr->minHeight = 0;
 
 	    /* Would just like to point to canonical empty chunk */
 	    chunkPtr->displayProc = (Tk_ChunkDisplayProc *) NULL;
@@ -1315,8 +1323,8 @@ LayoutDLine(textPtr, indexPtr)
 	    code = 1;
 	} else {
 	    code = (*segPtr->typePtr->layoutProc)(textPtr, &curIndex, segPtr,
-		byteOffset, maxX-tabSize, maxBytes, noCharsYet, wrapMode,
-		chunkPtr);
+		    byteOffset, maxX-tabSize, maxBytes, noCharsYet, wrapMode,
+		    chunkPtr);
 	}
 	if (code <= 0) {
 	    FreeStyle(textPtr, chunkPtr->stylePtr);
@@ -1332,8 +1340,8 @@ LayoutDLine(textPtr, indexPtr)
 	    }
 
 	    /*
-	     * No characters from this segment fit in the window: this
-	     * means we're at the end of the display line.
+	     * No characters from this segment fit in the window: this means
+	     * we're at the end of the display line.
 	     */
 
 	    if (chunkPtr != NULL) {
@@ -1363,9 +1371,9 @@ LayoutDLine(textPtr, indexPtr)
 
 	/*
 	 * If we're at a new tab, adjust the layout for all the chunks
-	 * pertaining to the previous tab.  Also adjust the amount of
-	 * space left in the line to account for space that will be eaten
-	 * up by the tab.
+	 * pertaining to the previous tab. Also adjust the amount of space
+	 * left in the line to account for space that will be eaten up by the
+	 * tab.
 	 */
 
 	if (gotTab) {
@@ -1385,12 +1393,13 @@ LayoutDLine(textPtr, indexPtr)
 	    byteOffset = 0;
 	    segPtr = segPtr->nextPtr;
 	    if (elide && segPtr == NULL) {
-		/* 
+		/*
 		 * An elided section started on this line, and carries on
-		 * until the newline.  Hence the newline is actually
-		 * elided, and we want to merge the display of the next
-		 * logical line with this one.
+		 * 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++;
@@ -1408,31 +1417,31 @@ LayoutDLine(textPtr, indexPtr)
 	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.
+
+	/*
+	 * 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);
 
     /*
-     * We're at the end of the display line.  Throw away everything
-     * after the most recent word break, if there is one;  this may
-     * potentially require the last chunk to be layed out again.
+     * We're at the end of the display line. Throw away everything after the
+     * most recent word break, if there is one; this may potentially require
+     * the last chunk to be layed out again.
      */
 
     if (breakChunkPtr == NULL) {
 	/*
-	 * This code makes sure that we don't accidentally display
-	 * chunks with no characters at the end of the line (such as
-	 * the insertion cursor).  These chunks belong on the next
-	 * line.  So, throw away everything after the last chunk that
-	 * has characters in it.
+	 * This code makes sure that we don't accidentally display chunks with
+	 * no characters at the end of the line (such as the insertion
+	 * cursor). These chunks belong on the next line. So, throw away
+	 * everything after the last chunk that has characters in it.
 	 */
 
 	breakChunkPtr = lastCharChunkPtr;
@@ -1454,7 +1463,7 @@ LayoutDLine(textPtr, indexPtr)
 	    (*breakChunkPtr->undisplayProc)(textPtr, breakChunkPtr);
 	    segPtr = TkTextIndexToSeg(&breakIndex, &byteOffset);
 	    (*segPtr->typePtr->layoutProc)(textPtr, &breakIndex,
-		    segPtr, byteOffset, maxX, breakByteOffset, 0, 
+		    segPtr, byteOffset, maxX, breakByteOffset, 0,
 		    wrapMode, breakChunkPtr);
 	}
 	lastChunkPtr = breakChunkPtr;
@@ -1471,16 +1480,15 @@ LayoutDLine(textPtr, indexPtr)
     }
 
     /*
-     * Make one more pass over the line to recompute various things
-     * like its height, length, and total number of bytes.  Also
-     * modify the x-locations of chunks to reflect justification.
-     * If we're not wrapping, I'm not sure what is the best way to
-     * handle left and center justification:  should the total length,
-     * for purposes of justification, be (a) the window width, (b)
-     * the length of the longest line in the window, or (c) the length
-     * of the longest line in the text?  (c) isn't available, (b) seems
-     * weird, since it can change with vertical scrolling, so (a) is
-     * what is implemented below.
+     * Make one more pass over the line to recompute various things like its
+     * height, length, and total number of bytes. Also modify the x-locations
+     * of chunks to reflect justification. If we're not wrapping, I'm not sure
+     * what is the best way to handle left and center justification: should
+     * the total length, for purposes of justification, be (a) the window
+     * width, (b) the length of the longest line in the window, or (c) the
+     * length of the longest line in the text? (c) isn't available, (b) seems
+     * weird, since it can change with vertical scrolling, so (a) is what is
+     * implemented below.
      */
 
     if (wrapMode == TEXT_WRAPMODE_NONE) {
@@ -1539,7 +1547,7 @@ LayoutDLine(textPtr, indexPtr)
      */
 
     dlPtr->length = lastChunkPtr->x + lastChunkPtr->width;
-    
+
     return dlPtr;
 }
 
@@ -1548,25 +1556,24 @@ LayoutDLine(textPtr, indexPtr)
  *
  * UpdateDisplayInfo --
  *
- *	This procedure is invoked to recompute some or all of the
- *	DLine structures for a text widget.  At the time it is called
- *	the DLine structures still left in the widget are guaranteed
- *	to be correct except that (a) the y-coordinates aren't
- *	necessarily correct, (b) there may be missing structures
- *	(the DLine structures get removed as soon as they are potentially
- *	out-of-date), and (c) DLine structures that don't start at the
- *	beginning of a line may be incorrect if previous information in
- *	the same line changed size in a way that moved a line boundary
- *	(DLines for any info that changed will have been deleted, but
- *	not DLines for unchanged info in the same text line).
+ *	This function is invoked to recompute some or all of the DLine
+ *	structures for a text widget. At the time it is called the DLine
+ *	structures still left in the widget are guaranteed to be correct
+ *	except that (a) the y-coordinates aren't necessarily correct, (b)
+ *	there may be missing structures (the DLine structures get removed as
+ *	soon as they are potentially out-of-date), and (c) DLine structures
+ *	that don't start at the beginning of a line may be incorrect if
+ *	previous information in the same line changed size in a way that moved
+ *	a line boundary (DLines for any info that changed will have been
+ *	deleted, but not DLines for unchanged info in the same text line).
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Upon return, the DLine information for textPtr correctly reflects
- *	the positions where characters will be displayed.  However, this
- *	procedure doesn't actually bring the display up-to-date.
+ *	Upon return, the DLine information for textPtr correctly reflects the
+ *	positions where characters will be displayed. However, this function
+ *	doesn't actually bring the display up-to-date.
  *
  *----------------------------------------------------------------------
  */
@@ -1603,12 +1610,12 @@ UpdateDisplayInfo(textPtr)
 
     /*
      *--------------------------------------------------------------
-     * Scan through the contents of the window from top to bottom,
-     * recomputing information for lines that are missing.
+     * Scan through the contents of the window from top to bottom, recomputing
+     * information for lines that are missing.
      *--------------------------------------------------------------
      */
 
-    lastLinePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree, textPtr, 
+    lastLinePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree, textPtr,
 	    TkBTreeNumLines(textPtr->sharedTextPtr->tree, textPtr));
     dlPtr = dInfoPtr->dLinePtr;
     prevPtr = NULL;
@@ -1625,38 +1632,35 @@ UpdateDisplayInfo(textPtr)
 	 * There are three possibilities right now:
 	 * (a) the next DLine (dlPtr) corresponds exactly to the next
 	 *     information we want to display: just use it as-is.
-	 * (b) the next DLine corresponds to a different line, or to
-	 *     a segment that will be coming later in the same line:
-	 *     leave this DLine alone in the hopes that we'll be able
-	 *     to use it later, then create a new DLine in front of
-	 *     it.
-	 * (c) the next DLine corresponds to a segment in the line we
-	 *     want, but it's a segment that has already been processed
-	 *     or will never be processed.  Delete the DLine and try
-	 *     again.
+	 * (b) the next DLine corresponds to a different line, or to a segment
+	 *     that will be coming later in the same line: leave this DLine
+	 *     alone in the hopes that we'll be able to use it later, then
+	 *     create a new DLine in front of it.
+	 * (c) the next DLine corresponds to a segment in the line we want,
+	 *     but it's a segment that has already been processed or will
+	 *     never be processed. Delete the DLine and try again.
 	 *
-	 * One other twist on all this.  It's possible for 3D borders
-	 * to interact between lines (see DisplayLineBackground) so if
-	 * a line is relayed out and has styles with 3D borders, its
-	 * neighbors have to be redrawn if they have 3D borders too,
-	 * since the interactions could have changed (the neighbors
-	 * don't have to be relayed out, just redrawn).
+	 * One other twist on all this. It's possible for 3D borders to
+	 * interact between lines (see DisplayLineBackground) so if a line is
+	 * relayed out and has styles with 3D borders, its neighbors have to
+	 * be redrawn if they have 3D borders too, since the interactions
+	 * could have changed (the neighbors don't have to be relayed out,
+	 * just redrawn).
 	 */
 
 	if ((dlPtr == NULL) || (dlPtr->index.linePtr != index.linePtr)) {
-	    
+
 	    /*
 	     * Case (b) -- must make new DLine.
 	     */
 
-	    makeNewDLine:
+	makeNewDLine:
 	    if (tkTextDebug) {
 		char string[TK_POS_CHARS];
 
 		/*
-		 * Debugging is enabled, so keep a log of all the lines
-		 * that were re-layed out.  The test suite uses this
-		 * information.
+		 * Debugging is enabled, so keep a log of all the lines that
+		 * were re-layed out. The test suite uses this information.
 		 */
 
 		TkTextPrintIndex(textPtr, &index, string);
@@ -1677,13 +1681,13 @@ UpdateDisplayInfo(textPtr)
 	    dlPtr = newPtr;
 	} else {
 	    /*
-	     * DlPtr refers to the line we want.  Next check the
-	     * index within the line.
+	     * DlPtr refers to the line we want. Next check the index within
+	     * the line.
 	     */
 
 	    if (index.byteIndex == dlPtr->index.byteIndex) {
 		/*
-		 * Case (a) -- can use existing display line as-is.
+		 * Case (a) - can use existing display line as-is.
 		 */
 
 		if ((dlPtr->flags & HAS_3D_BORDER) && (prevPtr != NULL)
@@ -1697,8 +1701,8 @@ UpdateDisplayInfo(textPtr)
 	    }
 
 	    /*
-	     * Case (c) -- dlPtr is useless.  Discard it and start
-	     * again with the next display line.
+	     * Case (c) - dlPtr is useless. Discard it and start again with
+	     * the next display line.
 	     */
 
 	    newPtr = dlPtr->nextPtr;
@@ -1716,7 +1720,7 @@ UpdateDisplayInfo(textPtr)
 	 * Advance to the start of the next line.
 	 */
 
-	lineOK:
+    lineOK:
 	dlPtr->y = y;
 	y += dlPtr->height;
 	if (lineHeight != -1) {
@@ -1727,8 +1731,8 @@ UpdateDisplayInfo(textPtr)
 	dlPtr = dlPtr->nextPtr;
 
 	/*
-	 * If we switched text lines, delete any DLines left for the
-	 * old text line.
+	 * If we switched text lines, delete any DLines left for the old text
+	 * line.
 	 */
 
 	if (index.linePtr != prevPtr->index.linePtr) {
@@ -1744,32 +1748,31 @@ UpdateDisplayInfo(textPtr)
 		prevPtr->nextPtr = nextPtr;
 		dlPtr = nextPtr;
 	    }
-	    
-	    if ((lineHeight != -1) 
-	      && (lineHeight != TkBTreeLinePixelCount(textPtr, 
-						     prevPtr->index.linePtr))) {
-		/* 
-		 * The logical line height we just calculated is
-		 * actually differnt to 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 are the same as counts made through the
-		 * BTree.  This helps to ensure that the scrollbar size
-		 * corresponds accurately to that displayed contents,
-		 * even as the window is re-sized.
+
+	    if ((lineHeight != -1) && (TkBTreeLinePixelCount(textPtr,
+		    prevPtr->index.linePtr) != lineHeight)) {
+		/*
+		 * The logical line height we just calculated is actually
+		 * differnt to 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 are the same as
+		 * counts made through the BTree. This helps to ensure that
+		 * the scrollbar size corresponds accurately to that displayed
+		 * contents, even as the window is re-sized.
 		 */
-		TkBTreeAdjustPixelHeight(textPtr, 
-					 prevPtr->index.linePtr, 
-					 lineHeight, 0);
-		/* 
+
+		TkBTreeAdjustPixelHeight(textPtr, prevPtr->index.linePtr,
+			lineHeight, 0);
+
+		/*
 		 * 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.
+		 * 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.
 		 */
+
 		TkBTreeLinePixelEpoch(textPtr, prevPtr->index.linePtr) =
 			dInfoPtr->lineMetricUpdateEpoch;
 	    }
@@ -1777,10 +1780,10 @@ UpdateDisplayInfo(textPtr)
 	}
 
 	/*
-	 * It's important to have the following check here rather than in
-	 * the while statement for the loop, so that there's always at least
-	 * one DLine generated, regardless of how small the window is.  This
-	 * keeps a lot of other code from breaking.
+	 * It's important to have the following check here rather than in the
+	 * while statement for the loop, so that there's always at least one
+	 * DLine generated, regardless of how small the window is. This keeps
+	 * a lot of other code from breaking.
 	 */
 
 	if (y >= maxY) {
@@ -1796,62 +1799,66 @@ UpdateDisplayInfo(textPtr)
 
     /*
      *--------------------------------------------------------------
-     * 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 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) {
 	/*
-	 * This counts how many vertical pixels we have left to fill
-	 * by pulling in more display pixels either from the first
-	 * currently displayed, or the lines above it.
+	 * This counts how many vertical pixels we have left to fill by
+	 * pulling in more display pixels either from the first currently
+	 * displayed, or the lines above it.
 	 */
+
 	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
+	    /*
+	     * 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).
+
+	    /*
+	     * 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;
 
 	    /*
-	     * 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.
+	     * 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;
 	    if (dInfoPtr->dLinePtr == NULL) {
-		/* 
-		 * No lines have been laid out.  This must be an empty
-		 * peer widget.
+		/*
+		 * No lines have been laid out. This must be an empty peer
+		 * widget.
 		 */
+
 		lineNum = -1;
 		bytesToCount = 0; /* Stop compiler warning */
 	    } else {
-		lineNum = TkBTreeLinesTo(textPtr, dInfoPtr->dLinePtr->index.linePtr);
+		lineNum = TkBTreeLinesTo(textPtr,
+			dInfoPtr->dLinePtr->index.linePtr);
 		bytesToCount = dInfoPtr->dLinePtr->index.byteIndex;
 		if (bytesToCount == 0) {
 		    bytesToCount = INT_MAX;
@@ -1860,9 +1867,9 @@ UpdateDisplayInfo(textPtr)
 	    }
 	    for ( ; (lineNum >= 0) && (spaceLeft > 0); lineNum--) {
 		int pixelHeight = 0;
-		
-		index.linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree, 
-						textPtr, lineNum);
+
+		index.linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree,
+			textPtr, lineNum);
 		index.byteIndex = 0;
 		lowestPtr = NULL;
 
@@ -1871,30 +1878,33 @@ UpdateDisplayInfo(textPtr)
 		    pixelHeight += dlPtr->height;
 		    dlPtr->nextPtr = lowestPtr;
 		    lowestPtr = dlPtr;
-		    if (dlPtr->length == 0 && dlPtr->height == 0) { 
-			bytesToCount--; break; 
+		    if (dlPtr->length == 0 && dlPtr->height == 0) {
+			bytesToCount--; break;
 		    }	/* elide */
-		    TkTextIndexForwBytes(textPtr, &index, dlPtr->byteCount, &index);
+		    TkTextIndexForwBytes(textPtr, &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).  
+
+		/*
+		 * 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 > TkBTreeLinePixelCount(textPtr, 
-							lowestPtr->index.linePtr)) {
-		    TkBTreeAdjustPixelHeight(textPtr, 
-					     lowestPtr->index.linePtr, 
-					     pixelHeight, 0);
+
+		if (pixelHeight > TkBTreeLinePixelCount(textPtr,
+			lowestPtr->index.linePtr)) {
+		    TkBTreeAdjustPixelHeight(textPtr,
+			    lowestPtr->index.linePtr, pixelHeight, 0);
 		    if (index.linePtr != lowestPtr->index.linePtr) {
-			/* 
-			 * We examined the entire line, so can update
-			 * the epoch.
+			/*
+			 * We examined the entire line, so can update the
+			 * epoch.
 			 */
-			TkBTreeLinePixelEpoch(textPtr, lowestPtr->index.linePtr) =
+
+			TkBTreeLinePixelEpoch(textPtr,
+				lowestPtr->index.linePtr) =
 				dInfoPtr->lineMetricUpdateEpoch;
 		    }
 		}
@@ -1925,36 +1935,37 @@ UpdateDisplayInfo(textPtr)
 		FreeDLines(textPtr, lowestPtr, (DLine *) NULL, DLINE_FREE);
 		bytesToCount = INT_MAX;
 	    }
+
 	    /*
-	     * We've either filled in the space we wanted to or we've
-	     * run out of display lines at the top of the text.  Note
-	     * that we already set dInfoPtr->newTopPixelOffset to zero
-	     * above.
+	     * We've either filled in the space we wanted to or we've run out
+	     * of display lines at the top of the text. Note that we already
+	     * set dInfoPtr->newTopPixelOffset to zero above.
 	     */
+
 	    if (spaceLeft < 0) {
-		/* 
-		 * We've laid out a few too many vertical pixels at or
-		 * above the first line.  Therefore we only want to show
-		 * part of the first displayed line, so that the last
-		 * displayed line just fits in the window.
+		/*
+		 * We've laid out a few too many vertical pixels at or above
+		 * the first line. Therefore we only want to show part of the
+		 * first displayed line, so that the last displayed line just
+		 * fits in the window.
 		 */
+
 		dInfoPtr->newTopPixelOffset = -spaceLeft;
-		if (dInfoPtr->newTopPixelOffset >= dInfoPtr->dLinePtr->height) {
-		    /* 
-		     * Somehow the entire first line we laid out is
-		     * shorter than the new offset.  This should not
-		     * occur and would indicate a bad problem in the
-		     * logic above.
+		if (dInfoPtr->newTopPixelOffset>=dInfoPtr->dLinePtr->height) {
+		    /*
+		     * Somehow the entire first line we laid out is shorter
+		     * than the new offset. This should not occur and would
+		     * indicate a bad problem in the logic above.
 		     */
+
 		    Tcl_Panic("Error in pixel height consistency while filling in spacesLeft");
 		}
 	    }
 	}
 
 	/*
-	 * Now we're all done except that the y-coordinates in all the
-	 * DLines are wrong and the top index for the text is wrong.
-	 * Update them.
+	 * Now we're all done except that the y-coordinates in all the DLines
+	 * are wrong and the top index for the text is wrong. Update them.
 	 */
 
 	if (dInfoPtr->dLinePtr != NULL) {
@@ -1966,20 +1977,19 @@ UpdateDisplayInfo(textPtr)
 		    Tcl_Panic("Added too many new lines in UpdateDisplayInfo");
 		}
 		dlPtr->y = y;
-		y += dlPtr->height; 
+		y += dlPtr->height;
 	    }
 	}
     }
 
     /*
      *--------------------------------------------------------------
-     * If the old top or bottom line has scrolled elsewhere on the
-     * screen, we may not be able to re-use its old contents by
-     * copying bits (e.g., a beveled edge that was drawn when it was
-     * at the top or bottom won't be drawn when the line is in the
-     * middle and its neighbor has a matching background).  Similarly,
-     * if the new top or bottom line came from somewhere else on the
-     * screen, we may not be able to copy the old bits.
+     * If the old top or bottom line has scrolled elsewhere on the screen, we
+     * may not be able to re-use its old contents by copying bits (e.g., a
+     * beveled edge that was drawn when it was at the top or bottom won't be
+     * drawn when the line is in the middle and its neighbor has a matching
+     * background). Similarly, if the new top or bottom line came from
+     * somewhere else on the screen, we may not be able to copy the old bits.
      *--------------------------------------------------------------
      */
 
@@ -1993,13 +2003,15 @@ UpdateDisplayInfo(textPtr)
 		    && (dlPtr->flags & HAS_3D_BORDER)) {
 		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.
+	     * 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) {
+
+	    if ((dlPtr->flags & TOP_LINE) &&
+		    dInfoPtr->topPixelOffset!=0 && dlPtr!=dInfoPtr->dLinePtr) {
 		dlPtr->flags |= OLD_Y_INVALID;
 	    }
 	    if ((dlPtr->flags & BOTTOM_LINE) && (dlPtr->nextPtr != NULL)
@@ -2021,7 +2033,7 @@ UpdateDisplayInfo(textPtr)
 	dInfoPtr->dLinePtr->flags |= TOP_LINE;
 	dInfoPtr->topPixelOffset = dInfoPtr->newTopPixelOffset;
     }
-    
+
     /*
      * Arrange for scrollbars to be updated.
      */
@@ -2031,12 +2043,11 @@ UpdateDisplayInfo(textPtr)
     /*
      *--------------------------------------------------------------
      * Deal with horizontal scrolling:
-     * 1. If there's empty space to the right of the longest line,
-     *    shift the screen to the right to fill in the empty space.
-     * 2. If the desired horizontal scroll position has changed,
-     *    force a full redisplay of all the lines in the widget.
-     * 3. If the wrap mode isn't "none" then re-scroll to the base
-     *    position.
+     * 1. If there's empty space to the right of the longest line, shift the
+     *	  screen to the right to fill in the empty space.
+     * 2. If the desired horizontal scroll position has changed, force a full
+     *	  redisplay of all the lines in the widget.
+     * 3. If the wrap mode isn't "none" then re-scroll to the base position.
      *--------------------------------------------------------------
      */
 
@@ -2056,20 +2067,21 @@ UpdateDisplayInfo(textPtr)
     if (xPixelOffset < 0) {
 	xPixelOffset = 0;
     }
-    
-    /* 
+
+    /*
      * Here's a problem: see the tests textDisp-29.2.1-4
-     * 
-     * If the widget is being created, but has not yet been configured
-     * it will have a maxY of 1 above, and we we won't have examined
-     * all the lines (just the first line, in fact), and so maxOffset
-     * will not be a true reflection of the widget's lines.  Therefore
-     * we must not overwrite the original newXPixelOffset in this case.
+     *
+     * If the widget is being created, but has not yet been configured it will
+     * have a maxY of 1 above, and we we won't have examined all the lines
+     * (just the first line, in fact), and so maxOffset will not be a true
+     * reflection of the widget's lines. Therefore we must not overwrite the
+     * original newXPixelOffset in this case.
      */
+
     if (!(((Tk_FakeWin *) (textPtr->tkwin))->flags & TK_NEED_CONFIG_NOTIFY)) {
 	dInfoPtr->newXPixelOffset = xPixelOffset;
     }
-    
+
     if (xPixelOffset != dInfoPtr->curXPixelOffset) {
 	dInfoPtr->curXPixelOffset = xPixelOffset;
 	for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL;
@@ -2084,8 +2096,8 @@ UpdateDisplayInfo(textPtr)
  *
  * FreeDLines --
  *
- *	This procedure is called to free up all of the resources
- *	associated with one or more DLine structures.
+ *	This function is called to free up all of the resources associated
+ *	with one or more DLine structures.
  *
  * Results:
  *	None.
@@ -2098,22 +2110,18 @@ UpdateDisplayInfo(textPtr)
 
 static void
 FreeDLines(textPtr, firstPtr, lastPtr, action)
-    TkText *textPtr;		/* Information about overall text
-				 * widget. */
+    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
+    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;
@@ -2125,9 +2133,8 @@ FreeDLines(textPtr, firstPtr, lastPtr, action)
 	    char string[TK_POS_CHARS];
 
 	    /*
-	     * Debugging is enabled, so keep a log of all the lines
-	     * whose height was recalculated.  The test suite uses this
-	     * information.
+	     * Debugging is enabled, so keep a log of all the lines whose
+	     * height was recalculated. The test suite uses this information.
 	     */
 
 	    TkTextPrintIndex(textPtr, &firstPtr->index, string);
@@ -2161,7 +2168,7 @@ FreeDLines(textPtr, firstPtr, lastPtr, action)
 	firstPtr = nextDLinePtr;
     }
     if (action != DLINE_FREE_TEMP) {
-        textPtr->dInfoPtr->dLinesInvalidated = 1;
+	textPtr->dInfoPtr->dLinesInvalidated = 1;
     }
 }
 
@@ -2170,16 +2177,14 @@ FreeDLines(textPtr, firstPtr, lastPtr, action)
  *
  * DisplayDLine --
  *
- *	This procedure is invoked to draw a single line on the
- *	screen.
+ *	This function is invoked to draw a single line on the screen.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The line given by dlPtr is drawn at its correct position in
- *	textPtr's window.  Note that this is one *display* line, not
- *	one *text* line.
+ *	The line given by dlPtr is drawn at its correct position in textPtr's
+ *	window. Note that this is one *display* line, not one *text* line.
  *
  *----------------------------------------------------------------------
  */
@@ -2188,11 +2193,11 @@ static void
 DisplayDLine(textPtr, dlPtr, prevPtr, pixmap)
     TkText *textPtr;		/* Text widget in which to draw line. */
     register DLine *dlPtr;	/* Information about line to draw. */
-    DLine *prevPtr;		/* Line just before one to draw, or NULL
-				 * if dlPtr is the top line. */
-    Pixmap pixmap;		/* Pixmap to use for double-buffering.
-				 * Caller must make sure it's large enough
-				 * to hold line. */
+    DLine *prevPtr;		/* Line just before one to draw, or NULL if
+				 * dlPtr is the top line. */
+    Pixmap pixmap;		/* Pixmap to use for double-buffering. Caller
+				 * must make sure it's large enough to hold
+				 * line. */
 {
     register TkTextDispChunk *chunkPtr;
     TextDInfo *dInfoPtr = textPtr->dInfoPtr;
@@ -2202,8 +2207,8 @@ DisplayDLine(textPtr, dlPtr, prevPtr, pixmap)
     if (dlPtr->chunkPtr == NULL) return;
 
     /*
-     * First, clear the area of the line to the background color for the
-     * text widget.
+     * First, clear the area of the line to the background color for the text
+     * widget.
      */
 
     display = Tk_Display(textPtr->tkwin);
@@ -2217,11 +2222,10 @@ DisplayDLine(textPtr, dlPtr, prevPtr, pixmap)
     DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap);
 
     /*
-     * Make another pass through all of the chunks to redraw the
-     * insertion cursor, if it is visible on this line.  Must do
-     * it here rather than in the foreground pass below because
-     * otherwise a wide insertion cursor will obscure the character
-     * to its left.
+     * Make another pass through all of the chunks to redraw the insertion
+     * cursor, if it is visible on this line. Must do it here rather than in
+     * the foreground pass below because otherwise a wide insertion cursor
+     * will obscure the character to its left.
      */
 
     if (textPtr->state == TK_TEXT_STATE_NORMAL) {
@@ -2239,39 +2243,41 @@ DisplayDLine(textPtr, dlPtr, prevPtr, pixmap)
 
     /*
      * Make yet another pass through all of the chunks to redraw all of
-     * foreground information.  Note:  we have to call the displayProc
-     * even for chunks that are off-screen.  This is needed, for
-     * example, so that embedded windows can be unmapped in this case.
+     * foreground information. Note: we have to call the displayProc even for
+     * chunks that are off-screen. This is needed, for example, so that
+     * embedded windows can be unmapped in this case.
      */
 
     for (chunkPtr = dlPtr->chunkPtr; (chunkPtr != NULL);
 	    chunkPtr = chunkPtr->nextPtr) {
 	if (chunkPtr->displayProc == TkTextInsertDisplayProc) {
 	    /*
-	     * Already displayed the insertion cursor above.  Don't
-	     * do it again here.
+	     * Already displayed the insertion cursor above. Don't do it again
+	     * here.
 	     */
 
 	    continue;
 	}
-	/* 
-	 * Don't call if elide.  This tax ok since not very many
-	 * visible DLine's in an area, but potentially many elide
-	 * ones
+
+	/*
+	 * 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 ((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).
+		 * 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)(textPtr, chunkPtr, x, dlPtr->spaceAbove,
@@ -2279,19 +2285,19 @@ DisplayDLine(textPtr, dlPtr, prevPtr, pixmap)
 		    dlPtr->baseline - dlPtr->spaceAbove, display, pixmap,
 		    dlPtr->y + dlPtr->spaceAbove);
 	}
-	
+
 	if (dInfoPtr->dLinesInvalidated) {
 	    return;
 	}
     }
 
     /*
-     * 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.
+     * 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;
@@ -2315,14 +2321,13 @@ DisplayDLine(textPtr, dlPtr, prevPtr, pixmap)
  *
  * DisplayLineBackground --
  *
- *	This procedure is called to fill in the background for
- *	a display line.  It draws 3D borders cleverly so that
- *	adjacent chunks with the same style (whether on the same
- *	line or different lines) have a single 3D border around
- *	the whole region.
+ *	This function is called to fill in the background for a display line.
+ *	It draws 3D borders cleverly so that adjacent chunks with the same
+ *	style (whether on the same line or different lines) have a single 3D
+ *	border around the whole region.
  *
  * Results:
- *	There is no return value.  Pixmap is filled in with background
+ *	There is no return value. Pixmap is filled in with background
  *	information for dlPtr.
  *
  * Side effects:
@@ -2335,46 +2340,44 @@ static void
 DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap)
     TkText *textPtr;		/* Text widget containing line. */
     register DLine *dlPtr;	/* Information about line to draw. */
-    DLine *prevPtr;		/* Line just above dlPtr, or NULL if dlPtr
-				 * is the top-most line in the window. */
-    Pixmap pixmap;		/* Pixmap to use for double-buffering.
-				 * Caller must make sure it's large enough
-				 * to hold line.  Caller must also have
-				 * filled it with the background color for
-				 * the widget. */
+    DLine *prevPtr;		/* Line just above dlPtr, or NULL if dlPtr is
+				 * the top-most line in the window. */
+    Pixmap pixmap;		/* Pixmap to use for double-buffering. Caller
+				 * must make sure it's large enough to hold
+				 * line. Caller must also have filled it with
+				 * the background color for the widget. */
 {
     TextDInfo *dInfoPtr = textPtr->dInfoPtr;
-    TkTextDispChunk *chunkPtr;  /* Pointer to chunk in the current line. */
-    TkTextDispChunk *chunkPtr2;	/* Pointer to chunk in the line above or
-				 * below the current one.  NULL if we're to
-				 * the left of or to the right of the chunks
-				 * in the line. */
+    TkTextDispChunk *chunkPtr;	/* Pointer to chunk in the current line. */
+    TkTextDispChunk *chunkPtr2;	/* Pointer to chunk in the line above or below
+				 * the current one. NULL if we're to the left
+				 * of or to the right of the chunks in the
+				 * line. */
     TkTextDispChunk *nextPtr2;	/* Next chunk after chunkPtr2 (it's not the
 				 * same as chunkPtr2->nextPtr in the case
-				 * where chunkPtr2 is NULL because the line
-				 * is indented). */
-    int leftX;			/* The left edge of the region we're
-				 * currently working on. */
+				 * where chunkPtr2 is NULL because the line is
+				 * indented). */
+    int leftX;			/* The left edge of the region we're currently
+				 * working on. */
     int leftXIn;		/* 1 means beveled edge at leftX slopes right
-				 * as it goes down, 0 means it slopes left
-				 * as it goes down. */
+				 * as it goes down, 0 means it slopes left as
+				 * it goes down. */
     int rightX;			/* Right edge of chunkPtr. */
     int rightX2;		/* Right edge of chunkPtr2. */
-    int matchLeft;		/* Does the style of this line match that
-				 * of its neighbor just to the left of
-				 * the current x coordinate? */
-    int matchRight;		/* Does line's style match its neighbor
-				 * just to the right of the current x-coord? */
+    int matchLeft;		/* Does the style of this line match that of
+				 * its neighbor just to the left of the
+				 * current x coordinate? */
+    int matchRight;		/* Does line's style match its neighbor just
+				 * to the right of the current x-coord? */
     int minX, maxX, xOffset;
     StyleValues *sValuePtr;
     Display *display;
 
 
     /*
-     * Pass 1: scan through dlPtr from left to right.  For each range of
-     * chunks with the same style, draw the main background for the style
-     * plus the vertical parts of the 3D borders (the left and right
-     * edges).
+     * Pass 1: scan through dlPtr from left to right. For each range of chunks
+     * with the same style, draw the main background for the style plus the
+     * vertical parts of the 3D borders (the left and right edges).
      */
 
     display = Tk_Display(textPtr->tkwin);
@@ -2384,19 +2387,17 @@ DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap)
     chunkPtr = dlPtr->chunkPtr;
 
     /*
-     * Note A: in the following statement, and a few others later in
-     * this file marked with "See Note A above", the right side of the
-     * assignment was replaced with 0 on 6/18/97.  This has the effect
-     * of highlighting the empty space to the left of a line whenever
-     * the leftmost character of the line is highlighted.  This way,
-     * multi-line highlights always line up along their left edges. 
-     * However, this may look funny in the case where a single word is
-     * highlighted. To undo the change, replace "leftX = 0" with "leftX
-     * = chunkPtr->x" and "rightX2 = 0" with "rightX2 = nextPtr2->x"
-     * here and at all the marked points below.  This restores the old
-     * behavior where empty space to the left of a line is not
-     * highlighted, leaving a ragged left edge for multi-line
-     * highlights.
+     * Note A: in the following statement, and a few others later in this file
+     * marked with "See Note A above", the right side of the assignment was
+     * replaced with 0 on 6/18/97. This has the effect of highlighting the
+     * empty space to the left of a line whenever the leftmost character of
+     * the line is highlighted. This way, multi-line highlights always line up
+     * along their left edges. However, this may look funny in the case where
+     * a single word is highlighted. To undo the change, replace "leftX = 0"
+     * with "leftX = chunkPtr->x" and "rightX2 = 0" with "rightX2 =
+     * nextPtr2->x" here and at all the marked points below. This restores the
+     * old behavior where empty space to the left of a line is not
+     * highlighted, leaving a ragged left edge for multi-line highlights.
      */
 
     leftX = 0;
@@ -2412,9 +2413,12 @@ DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap)
 	    rightX = maxX;
 	}
 	if (chunkPtr->stylePtr->bgGC != None) {
-	    /* Not visible - bail out now */
+	    /*
+	     * Not visible - bail out now.
+	     */
+
 	    if (rightX + xOffset <= 0) {
-	        leftX = rightX;
+		leftX = rightX;
 		continue;
 	    }
 
@@ -2424,11 +2428,12 @@ DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap)
 	     * -32768 (or less) to +something simply does not display
 	     * correctly. [Patch #541999]
 	     */
+
 	    if ((leftX + xOffset) < -(sValuePtr->borderWidth)) {
-	        leftX = -sValuePtr->borderWidth - xOffset;
+		leftX = -sValuePtr->borderWidth - xOffset;
 	    }
 	    if ((rightX - leftX) > 32767) {
-	        rightX = leftX + 32767;
+		rightX = leftX + 32767;
 	    }
 
 	    XFillRectangle(display, pixmap, chunkPtr->stylePtr->bgGC,
@@ -2448,9 +2453,9 @@ DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap)
     }
 
     /*
-     * Pass 2: draw the horizontal bevels along the top of the line.  To
-     * do this, scan through dlPtr from left to right while simultaneously
-     * scanning through the line just above dlPtr.  ChunkPtr2 and nextPtr2
+     * Pass 2: draw the horizontal bevels along the top of the line. To do
+     * this, scan through dlPtr from left to right while simultaneously
+     * scanning through the line just above dlPtr. ChunkPtr2 and nextPtr2
      * refer to two adjacent chunks in the line above.
      */
 
@@ -2491,8 +2496,8 @@ DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap)
 	sValuePtr = chunkPtr->stylePtr->sValuePtr;
 	if (rightX <= rightX2) {
 	    /*
-	     * The chunk in our line is about to end.  If its style
-	     * changes then draw the bevel for the current style.
+	     * The chunk in our line is about to end. If its style changes
+	     * then draw the bevel for the current style.
 	     */
 
 	    if ((chunkPtr->nextPtr == NULL)
@@ -2508,9 +2513,8 @@ DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap)
 		leftXIn = 1;
 
 		/*
-		 * If the chunk in the line above is also ending at
-		 * the same point then advance to the next chunk in
-		 * that line.
+		 * If the chunk in the line above is also ending at the same
+		 * point then advance to the next chunk in that line.
 		 */
 
 		if ((rightX == rightX2) && (chunkPtr2 != NULL)) {
@@ -2529,11 +2533,10 @@ DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap)
 	}
 
 	/*
-	 * The chunk in the line above is ending at an x-position where
-	 * there is no change in the style of the current line.  If the
-	 * style above matches the current line on one side of the change
-	 * but not on the other, we have to draw an L-shaped piece of
-	 * bevel.
+	 * The chunk in the line above is ending at an x-position where there
+	 * is no change in the style of the current line. If the style above
+	 * matches the current line on one side of the change but not on the
+	 * other, we have to draw an L-shaped piece of bevel.
 	 */
 
 	matchRight = (nextPtr2 != NULL)
@@ -2553,12 +2556,12 @@ DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap)
 		    rightX2 + xOffset, 0, sValuePtr->borderWidth,
 		    sValuePtr->borderWidth, 1, sValuePtr->relief);
 	    Tk_3DHorizontalBevel(textPtr->tkwin, pixmap, sValuePtr->border,
-		    leftX + xOffset, 0, rightX2 + sValuePtr->borderWidth -leftX,
+		    leftX + xOffset,0, rightX2 + sValuePtr->borderWidth -leftX,
 		    sValuePtr->borderWidth, leftXIn, 0, 1,
 		    sValuePtr->relief);
 	}
 
-	nextChunk2:
+    nextChunk2:
 	chunkPtr2 = nextPtr2;
 	if (chunkPtr2 == NULL) {
 	    rightX2 = INT_MAX;
@@ -2570,9 +2573,10 @@ DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap)
 	    }
 	}
     }
+
     /*
-     * Pass 3: draw the horizontal bevels along the bottom of the line.
-     * This uses the same approach as pass 2.
+     * Pass 3: draw the horizontal bevels along the bottom of the line. This
+     * uses the same approach as pass 2.
      */
 
     chunkPtr = dlPtr->chunkPtr;
@@ -2662,7 +2666,7 @@ DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap)
 		    sValuePtr->borderWidth, leftXIn, 1, 0, sValuePtr->relief);
 	}
 
-	nextChunk2b:
+    nextChunk2b:
 	chunkPtr2 = nextPtr2;
 	if (chunkPtr2 == NULL) {
 	    rightX2 = INT_MAX;
@@ -2681,16 +2685,15 @@ DisplayLineBackground(textPtr, dlPtr, prevPtr, pixmap)
  *
  * AsyncUpdateLineMetrics --
  *
- *	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.
+ *	This function 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.
@@ -2708,13 +2711,12 @@ AsyncUpdateLineMetrics(clientData)
     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.
+	 * The widget has been deleted.	 Don't do anything.
 	 */
 
 	if (--textPtr->refCount == 0) {
@@ -2724,7 +2726,7 @@ AsyncUpdateLineMetrics(clientData)
     }
 
     if (dInfoPtr->flags & REDRAW_PENDING) {
-	dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(1, 
+	dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(1,
 		AsyncUpdateLineMetrics, clientData);
 	return;
     }
@@ -2733,33 +2735,36 @@ AsyncUpdateLineMetrics(clientData)
     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'.
+     * Update the lines in blocks of about 24 recalculations, or 250+ lines
+     * examined, so we pass in 256 for 'doThisMuch'.
      */
-    lineNum = TkTextUpdateLineMetrics(textPtr, lineNum, 
+
+    lineNum = TkTextUpdateLineMetrics(textPtr, lineNum,
 	    dInfoPtr->lastMetricUpdateLine, 256);
 
     if (tkTextDebug) {
 	char buffer[2 * TCL_INTEGER_SPACE + 1];
 
 	sprintf(buffer, "%d %d", lineNum, dInfoPtr->lastMetricUpdateLine);
-	Tcl_SetVar2(textPtr->interp, "tk_textInvalidateLine", (char *) NULL, 
+	Tcl_SetVar2(textPtr->interp, "tk_textInvalidateLine", (char *) NULL,
 		    buffer, TCL_GLOBAL_ONLY|TCL_APPEND_VALUE|TCL_LIST_ELEMENT);
     }
-    
-    /* 
-     * If we're not in the middle of a long-line calculation 
-     * (metricEpoch == -1) and we've reached the last line, then
-     * we're done.
+
+    /*
+     * If we're not in the middle of a long-line calculation (metricEpoch==-1)
+     * and we've reached the last line, then we're done.
      */
-    if (dInfoPtr->metricEpoch == -1 
-      && lineNum == dInfoPtr->lastMetricUpdateLine) {
+
+    if (dInfoPtr->metricEpoch == -1
+	    && 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).
+	 * 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);
@@ -2768,11 +2773,12 @@ AsyncUpdateLineMetrics(clientData)
     }
     dInfoPtr->currentMetricUpdateLine = lineNum;
 
-    /* 
-     * Re-arm the timer.  We already have a refCount on the text widget
-     * so no need to adjust that.
+    /*
+     * Re-arm the timer. We already have a refCount on the text widget so no
+     * need to adjust that.
      */
-    dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(1, 
+
+    dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(1,
 	    AsyncUpdateLineMetrics, (ClientData) textPtr);
 }
 
@@ -2781,23 +2787,21 @@ AsyncUpdateLineMetrics(clientData)
  *
  * 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.
+ *	This function 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 function 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 function 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).
+ *	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.
@@ -2808,47 +2812,52 @@ AsyncUpdateLineMetrics(clientData)
 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). */
+    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->sharedTextPtr->tree, textPtr);
-    
+
     if (totalLines == 0) {
 	/* Empty peer widget */
-        return endLine;
+	return endLine;
     }
-    
+
     while (1) {
-	/* Get a suitable line */
+	/*
+	 * Get a suitable line.
+	 */
+
 	if (lineNum == -1 && linePtr == NULL) {
 	    lineNum = 0;
-	    linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree, 
-				      textPtr, lineNum);
+	    linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree, textPtr,
+		    lineNum);
 	} else {
 	    if (lineNum == -1 || linePtr == NULL) {
 		if (lineNum == -1) {
 		    lineNum = 0;
 		}
-		linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree, 
-					  textPtr, lineNum);
+		linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree,
+			textPtr, lineNum);
 	    } else {
 		lineNum++;
 		linePtr = TkBTreeNextLine(textPtr, linePtr);
 	    }
-	    /* 
+
+	    /*
 	     * If we're in the middle of a partial-line height calculation,
 	     * then we can't be done.
 	     */
+
 	    if (textPtr->dInfoPtr->metricEpoch == -1 && lineNum == endLine) {
-		/* 
+		/*
 		 * We have looped over all lines, so we're done.
-		 */ 
+		 */
+
 		break;
 	    }
 	}
@@ -2857,43 +2866,47 @@ TkTextUpdateLineMetrics(textPtr, lineNum, endLine, doThisMuch)
 	    if (tkTextDebug) {
 		char buffer[4 * TCL_INTEGER_SPACE + 3];
 
-		sprintf(buffer, "%d %d %d %d", lineNum, endLine, 
+		sprintf(buffer, "%d %d %d %d", lineNum, endLine,
 			totalLines, count);
-		Tcl_SetVar2(textPtr->interp, "tk_textInvalidateLine", 
-			    (char *) NULL, buffer, 
-			    TCL_GLOBAL_ONLY|TCL_APPEND_VALUE|TCL_LIST_ELEMENT);
+		Tcl_SetVar2(textPtr->interp, "tk_textInvalidateLine",
+			(char *) NULL, buffer,
+			TCL_GLOBAL_ONLY|TCL_APPEND_VALUE|TCL_LIST_ELEMENT);
 	    }
-	    
-	    /* Now update the line's metrics if necessary */
+
+	    /*
+	     * Now update the line's metrics if necessary.
+	     */
+
 	    if (TkBTreeLinePixelEpoch(textPtr, linePtr)
 		!= textPtr->dInfoPtr->lineMetricUpdateEpoch) {
 		if (doThisMuch == -1) {
-		    count += 8 * TkTextUpdateOneLine(textPtr, linePtr, 
-						     0, NULL, 0);
+		    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 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) {
+
+		    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.
+			/*
+			 * 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;
@@ -2902,68 +2915,80 @@ TkTextUpdateLineMetrics(textPtr, lineNum, endLine, doThisMuch)
 			indexPtr = &index;
 			pixelHeight = 0;
 		    }
-		    /* 
-		     * Update the line and update the counter, counting
-		     * 8 for each display line we actually re-layout.
+
+		    /*
+		     * 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);
-		    
+
+		    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.
+			 * 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
+			     * These have already been stored, unless we just
+			     * started the new line.
 			     */
+
 			    textPtr->dInfoPtr->metricIndex = index;
-			    textPtr->dInfoPtr->metricEpoch = 
-			              textPtr->sharedTextPtr->stateEpoch;
+			    textPtr->dInfoPtr->metricEpoch =
+				    textPtr->sharedTextPtr->stateEpoch;
 			}
-			textPtr->dInfoPtr->metricPixelHeight = 
-			              TkBTreeLinePixelCount(textPtr, linePtr);
+			textPtr->dInfoPtr->metricPixelHeight =
+				TkBTreeLinePixelCount(textPtr, linePtr);
 			break;
 		    } else {
-			/* We're done with this long line */
+			/*
+			 * We're done with this long line.
+			 */
+
 			textPtr->dInfoPtr->metricEpoch = -1;
 		    }
 		}
 	    } else {
-		/* 
-		 * This line is already up to date.   That means there's
-		 * nothing to do here.
+		/*
+		 * This line is already up to date. That means there's nothing
+		 * to do here.
 		 */
 	    }
 	} 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.
+	    /*
+	     * 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) {
 		lineNum = endLine;
 		break;
 	    }
-	    /* Set things up for the next loop through */
+
+	    /*
+	     * 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.
+	/*
+	 * If we were requested to provide a full update, then also update the
+	 * scrollbar.
 	 */
+
 	GetYView(textPtr->interp, textPtr, 1);
     }
     return lineNum;
@@ -2975,35 +3000,32 @@ TkTextUpdateLineMetrics(textPtr, lineNum, endLine, doThisMuch)
  * TkTextInvalidateLineMetrics, TextInvalidateLineMetrics --
  *
  *	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.
+ *	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. 
+ *	May schedule an asychronous callback.
  *
  *----------------------------------------------------------------------
  */
 
 void
 TkTextInvalidateLineMetrics(sharedTextPtr, textPtr, linePtr, lineCount, action)
-    TkSharedText *sharedTextPtr;/* Shared widget section for all peers, 
-                                 * or NULL. */
+    TkSharedText *sharedTextPtr;/* Shared widget section for all peers, or
+				 * NULL. */
     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). */ 
+    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). */
 {
     if (sharedTextPtr == NULL) {
 	TextInvalidateLineMetrics(textPtr, linePtr, lineCount, action);
@@ -3019,25 +3041,23 @@ TkTextInvalidateLineMetrics(sharedTextPtr, textPtr, linePtr, lineCount, action)
 static void
 TextInvalidateLineMetrics(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). */ 
+    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 = TkBTreeLinesTo(textPtr, linePtr);
 
-	/* 
-	 * Invalidate the height calculations of each line in the
-	 * given range.
+	/*
+	 * Invalidate the height calculations of each line in the given range.
 	 */
+
 	TkBTreeLinePixelEpoch(textPtr, linePtr) = 0;
 	while (counter > 0 && linePtr != 0) {
 	    linePtr = TkBTreeNextLine(textPtr, linePtr);
@@ -3046,16 +3066,17 @@ TextInvalidateLineMetrics(textPtr, linePtr, lineCount, action)
 	    }
 	    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.
+
+	/*
+	 * 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) {
@@ -3064,7 +3085,7 @@ TextInvalidateLineMetrics(textPtr, linePtr, lineCount, action)
 	    dInfoPtr->lastMetricUpdateLine = fromLine + lineCount + 1;
 	} else {
 	    int toLine = fromLine + lineCount + 1;
-	    
+
 	    if (action == TK_TEXT_INVALIDATE_DELETE) {
 		if (toLine <= dInfoPtr->currentMetricUpdateLine) {
 		    dInfoPtr->currentMetricUpdateLine = fromLine;
@@ -3114,25 +3135,29 @@ TextInvalidateLineMetrics(textPtr, linePtr, lineCount, action)
 	/*
 	 * 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.
+
+	/*
+	 * 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 
+
+    /*
+     * Now re-set the current update calculations
      */
+
     if (dInfoPtr->lineUpdateTimer == NULL) {
 	textPtr->refCount++;
-	dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(1, 
+	dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(1,
 		AsyncUpdateLineMetrics, (ClientData) textPtr);
     }
 }
@@ -3142,80 +3167,88 @@ TextInvalidateLineMetrics(textPtr, linePtr, lineCount, action)
  *
  * 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.
- *	
+ *	This function 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.
+ *
  * 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.
+ *
+ *	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!
+ *	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. */
+    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 */
+	/*
+	 * Nothing to do.
+	 */
+
 	if (xOffset != NULL) {
 	    *xOffset = 0;
 	}
-        return;
+	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 */
+		/*
+		 * 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).
+		 * 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.
+
+	    /*
+	     * 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;
 	}
@@ -3224,39 +3257,45 @@ TkTextFindDisplayLineEnd(textPtr, indexPtr, end, xOffset)
 	    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 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.
+
+	    /*
+	     * '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 
+
+	    if (((index.linePtr == indexPtr->linePtr)
+		    && (index.byteIndex + byteCount > indexPtr->byteIndex))
+		    || (dlPtr->logicalLinesMerged > 0
 		    && TkTextIndexCmp(&nextLineStart, indexPtr) > 0)) {
-		/* It's on this display line */
+		/*
+		 * 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.
+		    /*
+		     * 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);
+
+		    *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.
+		    /*
+		     * The index we want is one less than the number of bytes
+		     * in the display line.
 		     */
+
 		    TkTextIndexBackBytes(textPtr, &nextLineStart, 1, indexPtr);
 		} else {
 		    *indexPtr = index;
@@ -3275,61 +3314,58 @@ TkTextFindDisplayLineEnd(textPtr, indexPtr, end, xOffset)
  *
  * CalculateDisplayLineHeight --
  *
- *	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.
- *	
+ *	This function 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 function does not, in itself, update any cached information about
+ *	line heights. That should be done, where necessary, by its callers.
+ *
+ *	The behaviour of this function 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).
- *	
- *	If 'mergedLinePtr' is non-NULL, then returns in that pointer
- *	the number of extra logical lines merged into the given
- *	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).
+ *
+ *	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
- *	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!
+ *	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
 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). */
+    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.
+
+    /*
+     * Special case for artificial last line. May be better to move this
+     * inside LayoutDLine.
      */
-    if (indexPtr->byteIndex == 0 
-      && TkBTreeNextLine(textPtr, indexPtr->linePtr) == NULL) {
+
+    if (indexPtr->byteIndex == 0
+	    && TkBTreeNextLine(textPtr, indexPtr->linePtr) == NULL) {
 	if (byteCountPtr != NULL) {
 	    *byteCountPtr = 0;
 	}
@@ -3339,19 +3375,20 @@ CalculateDisplayLineHeight(textPtr, indexPtr, byteCountPtr, mergedLinePtr)
 	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
-     * which were mapped in the LayoutDLine call!
+    /*
+     * 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;
+	*byteCountPtr = dlPtr->byteCount;
     }
     if (mergedLinePtr != NULL) {
-        *mergedLinePtr = dlPtr->logicalLinesMerged;
+	*mergedLinePtr = dlPtr->logicalLinesMerged;
     }
     FreeDLines(textPtr, dlPtr, NULL, DLINE_FREE_TEMP);
 
@@ -3363,12 +3400,12 @@ CalculateDisplayLineHeight(textPtr, indexPtr, byteCountPtr, mergedLinePtr)
  *
  * 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.
- *	
+ *	This function 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).
@@ -3381,51 +3418,50 @@ CalculateDisplayLineHeight(textPtr, indexPtr, byteCountPtr, mergedLinePtr)
 
 int
 TkTextIndexYPixels(textPtr, indexPtr)
-    TkText *textPtr;              /* Widget record for text widget. */
+    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. */
+				   * distance from top of logical line to top
+				   * of index. */
 {
     int pixelHeight;
     TkTextIndex index;
-    
+
     pixelHeight = TkBTreePixelsTo(textPtr, 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'.
+
+    /*
+     * 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;
+	return pixelHeight;
     }
-    
+
     index.tree = textPtr->sharedTextPtr->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.
+
+	/*
+	 * 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 = CalculateDisplayLineHeight(textPtr, &index, &bytes, NULL);
-	
+
 	index.byteIndex += bytes;
-	
+
 	if (index.byteIndex > indexPtr->byteIndex) {
 	    return pixelHeight;
 	}
-	
+
 	if (height > 0) {
 	    pixelHeight += height;
 	}
@@ -3441,52 +3477,46 @@ TkTextIndexYPixels(textPtr, indexPtr)
  *
  * 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.
- *	
+ *	This function 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.
+ *	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 'CalculateDisplayLineHeight' for its side
- *	effects.
+ *	Line heights may be recalculated, and a timer to update the scrollbar
+ *	may be installed. Also see the called function
+ *	'CalculateDisplayLineHeight' for its side effects.
  *
  *----------------------------------------------------------------------
  */
 
 int
 TkTextUpdateOneLine(textPtr, linePtr, pixelHeight, indexPtr, partialCalc)
-    TkText *textPtr;        /* Widget record for text widget. */
-    TkTextLine *linePtr;    /* The line of which to calculate the
-                             * height. */
-    int pixelHeight;        /* If indexPtr is non-NULL, then this
-                             * is the number of pixels in the logical
-                             * line linePtr, up to the index which
-                             * has been given. */
-    TkTextIndex *indexPtr;  /* Either NULL or an index at the start of
-                             * a display line belonging to linePtr,
-                             * 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. */
+    TkText *textPtr;	    /* Widget record for text widget. */
+    TkTextLine *linePtr;    /* The line of which to calculate the height. */
+    int pixelHeight;	    /* If indexPtr is non-NULL, then this is the
+			     * number of pixels in the logical line linePtr,
+			     * up to the index which has been given. */
+    TkTextIndex *indexPtr;  /* Either NULL or an index at the start of a
+			     * display line belonging to linePtr, 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;
     int mergedLines;
-    
+
     if (indexPtr == NULL) {
 	index.tree = textPtr->sharedTextPtr->tree;
 	index.linePtr = linePtr;
@@ -3495,139 +3525,154 @@ TkTextUpdateOneLine(textPtr, linePtr, pixelHeight, indexPtr, partialCalc)
 	indexPtr = &index;
 	pixelHeight = 0;
     }
-    
-    /* 
-     * 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.
+
+    /*
+     * 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.
      */
 
     displayLines = 0;
     mergedLines = 0;
-    
+
     while (1) {
 	int bytes, height, logicalLines;
-	
-	/* 
-	 * 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.
+
+	/*
+	 * 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 = CalculateDisplayLineHeight(textPtr, indexPtr, &bytes, 
-					    &logicalLines);
-	
+
+	height = CalculateDisplayLineHeight(textPtr, indexPtr, &bytes,
+		&logicalLines);
+
 	if (height > 0) {
 	    pixelHeight += height;
 	    displayLines++;
 	}
-	
+
 	mergedLines += logicalLines;
-	
+
 	if (TkTextIndexForwBytes(textPtr, indexPtr, bytes, indexPtr)) {
-            break;
-        }
+	    break;
+	}
 
 	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.
+		/*
+		 * 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 */
+	    /*
+	     * 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.
+	     * 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.
 	     */
+
 	    TkTextIndex idx;
 	    TkTextIndexBackChars(textPtr, indexPtr, 1, &idx, COUNT_INDICES);
 	    if (!TkTextIsElided(textPtr, &idx, NULL)) {
-		/* We've ended a logical line */
+		/*
+		 * We've ended a logical line.
+		 */
+
 		partialCalc = 0;
 		break;
 	    }
-	    /* We must still be on the same wrapped line */
+
+	    /*
+	     * We must still be on the same wrapped line.
+	     */
 	}
 	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.
+	    /*
+	     * 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
-	 * just below).
+	/*
+	 * Mark the logical line as being up to date (caution: it isn't yet up
+	 * to date, that will happen in TkBTreeAdjustPixelHeight just below).
 	 */
-	TkBTreeLinePixelEpoch(textPtr, linePtr) 
-	                   = textPtr->dInfoPtr->lineMetricUpdateEpoch;
+
+	TkBTreeLinePixelEpoch(textPtr, linePtr)
+		= textPtr->dInfoPtr->lineMetricUpdateEpoch;
 	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 
+	     * (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;
+		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;
 	}
     }
-    
-    /* 
-     * We set the line's height, but the return value is now the height
-     * of the entire widget, which may be used just below for
-     * reporting/debugging purposes.
+
+    /*
+     * We set the line's height, but the return value is now the height of the
+     * entire widget, which may be used just below for reporting/debugging
+     * purposes.
      */
-    pixelHeight = TkBTreeAdjustPixelHeight(textPtr, linePtr, 
-					   pixelHeight, mergedLines);
-    
+
+    pixelHeight = TkBTreeAdjustPixelHeight(textPtr, linePtr, pixelHeight,
+	    mergedLines);
+
     if (tkTextDebug) {
 	char buffer[2 * TCL_INTEGER_SPACE + 1];
 
@@ -3636,12 +3681,12 @@ TkTextUpdateOneLine(textPtr, linePtr, pixelHeight, indexPtr, partialCalc)
 	}
 
 	sprintf(buffer, "%d %d", TkBTreeLinesTo(textPtr, linePtr), pixelHeight);
-	Tcl_SetVar2(textPtr->interp, "tk_textNumPixels", (char *) NULL, 
+	Tcl_SetVar2(textPtr->interp, "tk_textNumPixels", (char *) NULL,
 		    buffer, TCL_GLOBAL_ONLY|TCL_APPEND_VALUE|TCL_LIST_ELEMENT);
     }
     if (textPtr->dInfoPtr->scrollbarTimer == NULL) {
 	textPtr->refCount++;
-        textPtr->dInfoPtr->scrollbarTimer = Tcl_CreateTimerHandler(200, 
+	textPtr->dInfoPtr->scrollbarTimer = Tcl_CreateTimerHandler(200,
 		AsyncUpdateYScrollbar, (ClientData) textPtr);
     }
     return displayLines;
@@ -3652,9 +3697,8 @@ TkTextUpdateOneLine(textPtr, linePtr, pixelHeight, indexPtr, partialCalc)
  *
  * DisplayText --
  *
- *	This procedure is invoked as a when-idle handler to update the
- *	display.  It only redisplays the parts of the text widget that
- *	are out of date.
+ *	This function is invoked as a when-idle handler to update the display.
+ *	It only redisplays the parts of the text widget that are out of date.
  *
  * Results:
  *	None.
@@ -3675,14 +3719,13 @@ DisplayText(clientData)
     DLine *prevPtr;
     Pixmap pixmap;
     int maxHeight, borders;
-    int bottomY = 0;		/* Initialization needed only to stop
-				 * compiler warnings. */
+    int bottomY = 0;		/* Initialization needed only to stop compiler
+				 * warnings. */
     Tcl_Interp *interp;
 
     if ((textPtr->tkwin == NULL) || (textPtr->flags & DESTROYED)) {
-
 	/*
-	 * The widget has been deleted.  Don't do anything.
+	 * The widget has been deleted.	 Don't do anything.
 	 */
 
 	return;
@@ -3693,16 +3736,15 @@ DisplayText(clientData)
 
     if (tkTextDebug) {
 	Tcl_SetVar2(interp, "tk_textRelayout", (char *) NULL, "",
-                TCL_GLOBAL_ONLY);
+		TCL_GLOBAL_ONLY);
     }
 
     if ((textPtr->tkwin == NULL) || (textPtr->flags & DESTROYED)) {
-
 	/*
-	 * The widget has been deleted.  Don't do anything.
+	 * The widget has been deleted.	 Don't do anything.
 	 */
 
-        goto end;
+	goto end;
     }
 
     if (!Tk_IsMapped(textPtr->tkwin) || (dInfoPtr->maxX <= dInfoPtr->x)
@@ -3714,24 +3756,23 @@ DisplayText(clientData)
     numRedisplays++;
     if (tkTextDebug) {
 	Tcl_SetVar2(interp, "tk_textRedraw", (char *) NULL, "",
-                TCL_GLOBAL_ONLY);
+		TCL_GLOBAL_ONLY);
     }
 
     if ((textPtr->tkwin == NULL) || (textPtr->flags & DESTROYED)) {
-
 	/*
-	 * The widget has been deleted.  Don't do anything.
+	 * The widget has been deleted.	 Don't do anything.
 	 */
 
 	goto end;
     }
 
     /*
-     * Choose a new current item if that is needed (this could cause
-     * event handlers to be invoked, hence the preserve/release calls
-     * and the loop, since the handlers could conceivably necessitate
-     * yet another current item calculation).  The tkwin check is because
-     * the whole window could go away in the Tcl_Release call.
+     * Choose a new current item if that is needed (this could cause event
+     * handlers to be invoked, hence the preserve/release calls and the loop,
+     * since the handlers could conceivably necessitate yet another current
+     * item calculation). The tkwin check is because the whole window could go
+     * away in the Tcl_Release call.
      */
 
     while (dInfoPtr->flags & REPICK_NEEDED) {
@@ -3755,11 +3796,11 @@ DisplayText(clientData)
     dInfoPtr->dLinesInvalidated = 0;
 
     /*
-     * See if it's possible to bring some parts of the screen up-to-date
-     * 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.
+     * See if it's possible to bring some parts of the screen up-to-date 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) {
@@ -3767,37 +3808,37 @@ DisplayText(clientData)
 	int offset, height, y, oldY;
 	TkRegion damageRgn;
 
-	/* 
+	/*
 	 * 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).
+	 * 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))) {
+
+	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;
 	}
 
 	/*
-	 * This line is already drawn somewhere in the window so it only
-	 * needs to be copied to its new location.  See if there's a group
-	 * of lines that can all be copied together.
+	 * This line is already drawn somewhere in the window so it only needs
+	 * to be copied to its new location. See if there's a group of lines
+	 * that can all be copied together.
 	 */
 
 	offset = dlPtr->y - dlPtr->oldY;
@@ -3814,32 +3855,36 @@ DisplayText(clientData)
 	}
 
 	/*
-	 * Reduce the height of the area being copied if necessary to
-	 * avoid overwriting the border area.
+	 * 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).
+	    /*
+	     * 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.
+	 * 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 */
+	    /*
+	     * The DLine already has OLD_Y_INVALID cleared.
+	     */
+
 	    dlPtr->oldY = dlPtr->y;
 	    if (dlPtr->nextPtr == dlPtr2) {
 		break;
@@ -3848,9 +3893,9 @@ DisplayText(clientData)
 	}
 
 	/*
-	 * Scan through the lines following the copied ones to see if
-	 * we are going to overwrite them with the copy operation.
-	 * If so, mark them for redisplay.
+	 * Scan through the lines following the copied ones to see if we are
+	 * going to overwrite them with the copy operation. If so, mark them
+	 * for redisplay.
 	 */
 
 	for ( ; dlPtr2 != NULL; dlPtr2 = dlPtr2->nextPtr) {
@@ -3862,9 +3907,8 @@ DisplayText(clientData)
 	}
 
 	/*
-	 * Now scroll the lines.  This may generate damage which we
-	 * handle by calling TextInvalidateRegion to mark the display
-	 * blocks as stale.
+	 * Now scroll the lines. This may generate damage which we handle by
+	 * calling TextInvalidateRegion to mark the display blocks as stale.
 	 */
 
 	damageRgn = TkCreateRegion();
@@ -3879,14 +3923,13 @@ DisplayText(clientData)
     }
 
     /*
-     * Clear the REDRAW_PENDING flag here.  This is actually pretty
-     * tricky.  We want to wait until *after* doing the scrolling,
-     * since that could generate more areas to redraw and don't
-     * want to reschedule a redisplay for them.  On the other hand,
-     * we can't wait until after all the redisplaying, because the
-     * act of redisplaying could actually generate more redisplays
-     * (e.g. in the case of a nested window with event bindings triggered
-     * by redisplay).
+     * Clear the REDRAW_PENDING flag here. This is actually pretty tricky. We
+     * want to wait until *after* doing the scrolling, since that could
+     * generate more areas to redraw and don't want to reschedule a redisplay
+     * for them. On the other hand, we can't wait until after all the
+     * redisplaying, because the act of redisplaying could actually generate
+     * more redisplays (e.g. in the case of a nested window with event
+     * bindings triggered by redisplay).
      */
 
     dInfoPtr->flags &= ~REDRAW_PENDING;
@@ -3901,14 +3944,13 @@ DisplayText(clientData)
 		    TCL_GLOBAL_ONLY|TCL_APPEND_VALUE|TCL_LIST_ELEMENT);
 	}
 
-        if (textPtr->tkwin == NULL) {
-
+	if (textPtr->tkwin == NULL) {
 	    /*
-             * The widget has been deleted.  Don't do anything.
-             */
+	     * The widget has been deleted. Don't do anything.
+	     */
 
-            goto end;
-        }
+	    goto end;
+	}
 
 	Tk_Draw3DRectangle(textPtr->tkwin, Tk_WindowId(textPtr->tkwin),
 		textPtr->border, textPtr->highlightWidth,
@@ -3918,17 +3960,17 @@ DisplayText(clientData)
 		textPtr->borderWidth, textPtr->relief);
 	if (textPtr->highlightWidth != 0) {
 	    GC fgGC, bgGC;
-    
+
 	    bgGC = Tk_GCForColor(textPtr->highlightBgColorPtr,
 			Tk_WindowId(textPtr->tkwin));
 	    if (textPtr->flags & GOT_FOCUS) {
 		fgGC = Tk_GCForColor(textPtr->highlightColorPtr,
 			Tk_WindowId(textPtr->tkwin));
-	        TkpDrawHighlightBorder(textPtr->tkwin, fgGC, bgGC, 
-		        textPtr->highlightWidth, Tk_WindowId(textPtr->tkwin));
+		TkpDrawHighlightBorder(textPtr->tkwin, fgGC, bgGC,
+			textPtr->highlightWidth, Tk_WindowId(textPtr->tkwin));
 	    } else {
-	        TkpDrawHighlightBorder(textPtr->tkwin, bgGC, bgGC, 
-		        textPtr->highlightWidth, Tk_WindowId(textPtr->tkwin));
+		TkpDrawHighlightBorder(textPtr->tkwin, bgGC, bgGC,
+			textPtr->highlightWidth, Tk_WindowId(textPtr->tkwin));
 	    }
 	}
 	borders = textPtr->borderWidth + textPtr->highlightWidth;
@@ -3960,32 +4002,33 @@ DisplayText(clientData)
     }
 
     /*
-     * Now we have to redraw the lines that couldn't be updated by
-     * scrolling.  First, compute the height of the largest line and
-     * allocate an off-screen pixmap to use for double-buffered
-     * displays.
+     * Now we have to redraw the lines that couldn't be updated by scrolling.
+     * First, compute the height of the largest line and allocate an
+     * off-screen pixmap to use for double-buffered displays.
      */
 
     maxHeight = -1;
     for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL;
 	    dlPtr = dlPtr->nextPtr) {
-	if ((dlPtr->height > maxHeight) 
+	if ((dlPtr->height > maxHeight)
 	  && ((dlPtr->flags & OLD_Y_INVALID) || (dlPtr->oldY != dlPtr->y))) {
 	    maxHeight = dlPtr->height;
 	}
 	bottomY = dlPtr->y + dlPtr->height;
     }
-    /* 
+
+    /*
      * 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'.
+     * 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),
@@ -3997,6 +4040,7 @@ DisplayText(clientData)
 	    if ((dlPtr->flags & OLD_Y_INVALID) || dlPtr->oldY != dlPtr->y) {
 		if (tkTextDebug) {
 		    char string[TK_POS_CHARS];
+
 		    TkTextPrintIndex(textPtr, &dlPtr->index, string);
 		    Tcl_SetVar2(textPtr->interp, "tk_textRedraw",
 			    (char *) NULL, string,
@@ -4009,25 +4053,25 @@ DisplayText(clientData)
 		}
 		dlPtr->oldY = dlPtr->y;
 		dlPtr->flags &= ~(NEW_LAYOUT | OLD_Y_INVALID);
-	    } else if (dlPtr->chunkPtr != NULL && ((dlPtr->y < 0) 
-		       || (dlPtr->y + dlPtr->height > dInfoPtr->maxY))) {
+	    } 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
+		/*
+		 * 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.
+		 *
+		 * 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;
@@ -4038,33 +4082,35 @@ DisplayText(clientData)
 		    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).
+			 * 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(textPtr, chunkPtr, 
-			x, dlPtr->spaceAbove,
-			dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow,
-			dlPtr->baseline - dlPtr->spaceAbove, (Display *) NULL, 
-			(Drawable) None, dlPtr->y + dlPtr->spaceAbove);
+		    TkTextEmbWinDisplayProc(textPtr, chunkPtr, x,
+			    dlPtr->spaceAbove,
+			    dlPtr->height-dlPtr->spaceAbove-dlPtr->spaceBelow,
+			    dlPtr->baseline - dlPtr->spaceAbove,
+			    (Display *) NULL, (Drawable) None,
+			    dlPtr->y + dlPtr->spaceAbove);
 		}
- 	       
+
 	    }
 	}
 	Tk_FreePixmap(Tk_Display(textPtr->tkwin), pixmap);
     }
 
     /*
-     * See if we need to refresh the part of the window below the
-     * last line of text (if there is any such area).  Refresh the
-     * padding area on the left too, since the insertion cursor might
-     * have been displayed there previously).
+     * See if we need to refresh the part of the window below the last line of
+     * text (if there is any such area). Refresh the padding area on the left
+     * too, since the insertion cursor might have been displayed there
+     * previously).
      */
 
     if (dInfoPtr->topOfEof > dInfoPtr->maxY) {
@@ -4077,14 +4123,13 @@ DisplayText(clientData)
 		    TCL_GLOBAL_ONLY|TCL_APPEND_VALUE|TCL_LIST_ELEMENT);
 	}
 
-        if ((textPtr->tkwin == NULL) || (textPtr->flags & DESTROYED)) {
-
+	if ((textPtr->tkwin == NULL) || (textPtr->flags & DESTROYED)) {
 	    /*
-             * The widget has been deleted.  Don't do anything.
-             */
+	     * The widget has been deleted. Don't do anything.
+	     */
 
-            goto end;
-        }
+	    goto end;
+	}
 
 	Tk_Fill3DRectangle(textPtr->tkwin, Tk_WindowId(textPtr->tkwin),
 		textPtr->border, dInfoPtr->x - textPtr->padX, bottomY,
@@ -4093,28 +4138,27 @@ DisplayText(clientData)
     }
     dInfoPtr->topOfEof = bottomY;
 
-    doScrollbars:
+  doScrollbars:
 
     /*
-     * Update the vertical scrollbar, if there is one.  Note:  it's
-     * important to clear REDRAW_PENDING here, just in case the
-     * scroll procedure does something that requires redisplay.
+     * Update the vertical scrollbar, if there is one. Note: it's important to
+     * clear REDRAW_PENDING here, just in case the scroll function does
+     * something that requires redisplay.
      */
-    
+
     if (textPtr->flags & UPDATE_SCROLLBARS) {
 	textPtr->flags &= ~UPDATE_SCROLLBARS;
 	if (textPtr->yScrollCmd != NULL) {
 	    GetYView(textPtr->interp, textPtr, 1);
 	}
 
-        if ((textPtr->tkwin == NULL) || (textPtr->flags & DESTROYED)) {
-
+	if ((textPtr->tkwin == NULL) || (textPtr->flags & DESTROYED)) {
 	    /*
-             * The widget has been deleted.  Don't do anything.
-             */
+	     * The widget has been deleted. Don't do anything.
+	     */
 
-            goto end;
-        }
+	    goto end;
+	}
 
 	/*
 	 * Update the horizontal scrollbar, if any.
@@ -4125,7 +4169,7 @@ DisplayText(clientData)
 	}
     }
 
-end:
+  end:
     Tcl_Release((ClientData) interp);
 }
 
@@ -4134,9 +4178,8 @@ end:
  *
  * TkTextEventuallyRepick --
  *
- *	This procedure is invoked whenever something happens that
- *	could change the current character or the tags associated
- *	with it.
+ *	This function is invoked whenever something happens that could change
+ *	the current character or the tags associated with it.
  *
  * Results:
  *	None.
@@ -4166,9 +4209,9 @@ TkTextEventuallyRepick(textPtr)
  *
  * TkTextRedrawRegion --
  *
- *	This procedure is invoked to schedule a redisplay for a given
- *	region of a text widget.  The redisplay itself may not occur
- *	immediately:  it's scheduled as a when-idle handler.
+ *	This function is invoked to schedule a redisplay for a given region of
+ *	a text widget. The redisplay itself may not occur immediately: it's
+ *	scheduled as a when-idle handler.
  *
  * Results:
  *	None.
@@ -4183,9 +4226,9 @@ TkTextEventuallyRepick(textPtr)
 void
 TkTextRedrawRegion(textPtr, x, y, width, height)
     TkText *textPtr;		/* Widget record for text widget. */
-    int x, y;			/* Coordinates of upper-left corner of area
-				 * to be redrawn, in pixels relative to
-				 * textPtr's window. */
+    int x, y;			/* Coordinates of upper-left corner of area to
+				 * be redrawn, in pixels relative to textPtr's
+				 * window. */
     int width, height;		/* Width and height of area to be redrawn. */
 {
     TextDInfo *dInfoPtr = textPtr->dInfoPtr;
@@ -4242,10 +4285,9 @@ TextInvalidateRegion(textPtr, region)
     maxY = rect.y + rect.height;
     for (dlPtr = dInfoPtr->dLinePtr; dlPtr != NULL;
 	    dlPtr = dlPtr->nextPtr) {
-	if ((!(dlPtr->flags & OLD_Y_INVALID)) 
-	    && (TkRectInRegion(region, rect.x, dlPtr->y, 
-			       rect.width, (unsigned int) dlPtr->height) 
-		!= RectangleOut)) {
+	if ((!(dlPtr->flags & OLD_Y_INVALID))
+		&& (TkRectInRegion(region, rect.x, dlPtr->y,
+		rect.width, (unsigned int) dlPtr->height) != RectangleOut)) {
 	    dlPtr->flags |= OLD_Y_INVALID;
 	}
     }
@@ -4254,8 +4296,7 @@ TextInvalidateRegion(textPtr, region)
     }
 
     /*
-     * Schedule the redisplay operation if there isn't one already
-     * scheduled.
+     * Schedule the redisplay operation if there isn't one already scheduled.
      */
 
     inset = textPtr->borderWidth + textPtr->highlightWidth;
@@ -4273,24 +4314,23 @@ TextInvalidateRegion(textPtr, region)
  *
  * TkTextChanged, TextChanged --
  *
- *	This procedure is invoked when info in a text widget is about
- *	to be modified in a way that changes how it is displayed (e.g.
- *	characters were inserted or deleted, or tag information was
- *	changed).  This procedure must be called *before* a change is
- *	made, so that indexes in the display information are still
- *	valid.
- *	
- *	Note: if the range of indices may change geometry as well
- *	as simply requiring redisplay, then the caller should also
- *	call TkTextInvalidateLineMetrics.
+ *	This function is invoked when info in a text widget is about to be
+ *	modified in a way that changes how it is displayed (e.g. characters
+ *	were inserted or deleted, or tag information was changed). This
+ *	function 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.
  *
  * Side effects:
- *	The range of character between index1Ptr (inclusive) and
- *	index2Ptr (exclusive) will be redisplayed at some point in the
- *	future (the actual redisplay is scheduled as a when-idle handler).
+ *	The range of character between index1Ptr (inclusive) and index2Ptr
+ *	(exclusive) will be redisplayed at some point in the future (the
+ *	actual redisplay is scheduled as a when-idle handler).
  *
  *----------------------------------------------------------------------
  */
@@ -4298,12 +4338,11 @@ TextInvalidateRegion(textPtr, region)
 void
 TkTextChanged(sharedTextPtr, textPtr, index1Ptr, index2Ptr)
     TkSharedText *sharedTextPtr;  /* Shared widget section, or NULL */
-    TkText *textPtr;		  /* Widget record for text widget,
-                    		   * or NULL. */
-    CONST TkTextIndex *index1Ptr; /* Index of first character to 
-                                   * redisplay. */
-    CONST TkTextIndex *index2Ptr; /* Index of character just after last one
-				   * to redisplay. */
+    TkText *textPtr;		  /* Widget record for text widget, or
+				   * NULL. */
+    CONST TkTextIndex *index1Ptr; /* Index of first character to redisplay. */
+    CONST TkTextIndex *index2Ptr; /* Index of character just after last one to
+				   * redisplay. */
 {
     if (sharedTextPtr == NULL) {
 	TextChanged(textPtr, index1Ptr, index2Ptr);
@@ -4318,12 +4357,11 @@ TkTextChanged(sharedTextPtr, textPtr, index1Ptr, index2Ptr)
 
 static void
 TextChanged(textPtr, index1Ptr, index2Ptr)
-    TkText *textPtr;		  /* Widget record for text widget,
-				   * or NULL. */
-    CONST TkTextIndex *index1Ptr; /* Index of first character to 
+    TkText *textPtr;		  /* Widget record for text widget, or
+				   * NULL. */
+    CONST TkTextIndex *index1Ptr; /* Index of first character to redisplay. */
+    CONST TkTextIndex *index2Ptr; /* Index of character just after last one to
 				   * redisplay. */
-    CONST TkTextIndex *index2Ptr; /* Index of character just after last one
-				   * to redisplay. */
 {
     TextDInfo *dInfoPtr = textPtr->dInfoPtr;
     DLine *firstPtr, *lastPtr;
@@ -4331,18 +4369,18 @@ TextChanged(textPtr, index1Ptr, index2Ptr)
 
     /*
      * Schedule both a redisplay and a recomputation of display information.
-     * It's done here rather than the end of the procedure for two reasons:
+     * It's done here rather than the end of the function for two reasons:
      *
      * 1. If there are no display lines to update we'll want to return
-     *    immediately, well before the end of the procedure.
+     *	  immediately, well before the end of the function.
      * 2. It's important to arrange for the redisplay BEFORE calling
-     *    FreeDLines.  The reason for this is subtle and has to do with
-     *    embedded windows.  The chunk delete procedure for an embedded
-     *    window will schedule an idle handler to unmap the window.
-     *    However, we want the idle handler for redisplay to be called
-     *    first, so that it can put the embedded window back on the screen
-     *    again (if appropriate).  This will prevent the window from ever
-     *    being unmapped, and thereby avoid flashing.
+     *	  FreeDLines. The reason for this is subtle and has to do with
+     *	  embedded windows. The chunk delete function for an embedded window
+     *	  will schedule an idle handler to unmap the window. However, we want
+     *	  the idle handler for redisplay to be called first, so that it can
+     *	  put the embedded window back on the screen again (if appropriate).
+     *	  This will prevent the window from ever being unmapped, and thereby
+     *	  avoid flashing.
      */
 
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
@@ -4351,13 +4389,13 @@ TextChanged(textPtr, index1Ptr, index2Ptr)
     dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED;
 
     /*
-     * Find the DLines corresponding to index1Ptr and index2Ptr.  There
-     * is one tricky thing here, which is that we have to relayout in
-     * units of whole text lines:  round index1Ptr back to the beginning
-     * of its text line, and include all the display lines after index2,
-     * up to the end of its text line.  This is necessary because the
-     * indices stored in the display lines will no longer be valid.  It's
-     * also needed because any edit could change the way lines wrap.
+     * Find the DLines corresponding to index1Ptr and index2Ptr. There is one
+     * tricky thing here, which is that we have to relayout in units of whole
+     * text lines: round index1Ptr back to the beginning of its text line, and
+     * include all the display lines after index2, up to the end of its text
+     * line. This is necessary because the indices stored in the display lines
+     * will no longer be valid. It's also needed because any edit could change
+     * the way lines wrap.
      */
 
     rounded = *index1Ptr;
@@ -4384,30 +4422,30 @@ TextChanged(textPtr, index1Ptr, index2Ptr)
  *
  * TkTextRedrawTag, TextRedrawTag --
  *
- *	This procedure is invoked to request a redraw of all characters
- *	in a given range that have a particular tag on or off.  It's
- *	called, for example, when tag options change.
+ *	This function is invoked to request a redraw of all characters in a
+ *	given range that have a particular tag on or off. It's called, for
+ *	example, when tag options change.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Information on the screen may be redrawn, and the layout of
- *	the screen may change.
+ *	Information on the screen may be redrawn, and the layout of the screen
+ *	may change.
  *
  *----------------------------------------------------------------------
  */
 
 void
 TkTextRedrawTag(sharedTextPtr, textPtr, index1Ptr, index2Ptr, tagPtr, withTag)
-    TkSharedText *sharedTextPtr;  /* Shared widget section, or NULL */
+    TkSharedText *sharedTextPtr;/* Shared widget section, or NULL */
     TkText *textPtr;		/* Widget record for text widget. */
-    TkTextIndex *index1Ptr;	/* First character in range to consider
-				 * for redisplay.  NULL means start at
-				 * beginning of text. */
+    TkTextIndex *index1Ptr;	/* First character in range to consider for
+				 * redisplay. NULL means start at beginning of
+				 * text. */
     TkTextIndex *index2Ptr;	/* Character just after last one to consider
-				 * for redisplay.  NULL means process all
-				 * the characters in the text. */
+				 * for redisplay. NULL means process all the
+				 * characters in the text. */
     TkTextTag *tagPtr;		/* Information about tag. */
     int withTag;		/* 1 means redraw characters that have the
 				 * tag, 0 means redraw those without. */
@@ -4426,12 +4464,12 @@ TkTextRedrawTag(sharedTextPtr, textPtr, index1Ptr, index2Ptr, tagPtr, withTag)
 static void
 TextRedrawTag(textPtr, index1Ptr, index2Ptr, tagPtr, withTag)
     TkText *textPtr;		/* Widget record for text widget. */
-    TkTextIndex *index1Ptr;	/* First character in range to consider
-				 * for redisplay.  NULL means start at
-				 * beginning of text. */
+    TkTextIndex *index1Ptr;	/* First character in range to consider for
+				 * redisplay. NULL means start at beginning of
+				 * text. */
     TkTextIndex *index2Ptr;	/* Character just after last one to consider
-				 * for redisplay.  NULL means process all
-				 * the characters in the text. */
+				 * for redisplay. NULL means process all the
+				 * characters in the text. */
     TkTextTag *tagPtr;		/* Information about tag. */
     int withTag;		/* 1 means redraw characters that have the
 				 * tag, 0 means redraw those without. */
@@ -4444,18 +4482,19 @@ TextRedrawTag(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.
+    /*
+     * 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;
+	TkTextLine *startLine, *endLine;
 	int lineCount;
+
 	if (index2Ptr == NULL) {
 	    endLine = NULL;
 	    lineCount = TkBTreeNumLines(textPtr->sharedTextPtr->tree, textPtr);
@@ -4469,20 +4508,20 @@ TextRedrawTag(textPtr, index1Ptr, index2Ptr, tagPtr, withTag)
 	    startLine = index1Ptr->linePtr;
 	    lineCount -= TkBTreeLinesTo(textPtr, startLine);
 	}
-	TkTextInvalidateLineMetrics(NULL, textPtr, startLine, lineCount, 
-				    TK_TEXT_INVALIDATE_ONLY);
+	TkTextInvalidateLineMetrics(NULL, textPtr, startLine, lineCount,
+		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).
+     * Round up the starting position if it's before the first line visible on
+     * the screen (we only care about what's on the screen).
      */
 
     dlPtr = dInfoPtr->dLinePtr;
     if (dlPtr == NULL) {
 	return;
     }
-    if ((index1Ptr == NULL) || (TkTextIndexCmp(&dlPtr->index, index1Ptr) > 0)) {
+    if ((index1Ptr == NULL) || (TkTextIndexCmp(&dlPtr->index, index1Ptr)>0)) {
 	index1Ptr = &dlPtr->index;
     }
 
@@ -4492,22 +4531,25 @@ TextRedrawTag(textPtr, index1Ptr, index2Ptr, tagPtr, withTag)
 
     if (index2Ptr == NULL) {
 	int lastLine = TkBTreeNumLines(textPtr->sharedTextPtr->tree, textPtr);
+
 	index2Ptr = TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr,
-					lastLine, 0, &endOfText);
+		lastLine, 0, &endOfText);
     }
 
-    /* 
-     * Initialize a search through all transitions on the tag, starting
-     * with the first transition where the tag's current state is different
-     * from what it will eventually be.
+    /*
+     * Initialize a search through all transitions on the tag, starting with
+     * the first transition where the tag's current state is different from
+     * what it will eventually be.
      */
 
     TkBTreeStartSearch(index1Ptr, index2Ptr, tagPtr, &search);
+
     /*
-     * Make our own curIndex because at this point search.curIndex
-     * may not equal index1Ptr->curIndex in the case the first tag toggle
-     * comes after index1Ptr (See the use of FindTagStart in TkBTreeStartSearch)
+     * Make our own curIndex because at this point search.curIndex may not
+     * equal index1Ptr->curIndex in the case the first tag toggle comes after
+     * index1Ptr (See the use of FindTagStart in TkBTreeStartSearch).
      */
+
     curIndexPtr = index1Ptr;
     tagOn = TkBTreeCharTagged(index1Ptr, tagPtr);
     if (tagOn != withTag) {
@@ -4518,9 +4560,9 @@ TextRedrawTag(textPtr, index1Ptr, index2Ptr, tagPtr, withTag)
     }
 
     /*
-     * Schedule a redisplay and layout recalculation if they aren't
-     * already pending.  This has to be done before calling FreeDLines,
-     * for the reason given in TkTextChanged.
+     * Schedule a redisplay and layout recalculation if they aren't already
+     * pending. This has to be done before calling FreeDLines, for the reason
+     * given in TkTextChanged.
      */
 
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
@@ -4529,21 +4571,20 @@ TextRedrawTag(textPtr, index1Ptr, index2Ptr, tagPtr, withTag)
     dInfoPtr->flags |= REDRAW_PENDING|DINFO_OUT_OF_DATE|REPICK_NEEDED;
 
     /*
-     * Each loop through the loop below is for one range of characters
-     * where the tag's current state is different than its eventual
-     * state.  At the top of the loop, search contains information about
-     * the first character in the range.
+     * Each loop through the loop below is for one range of characters where
+     * the tag's current state is different than its eventual state. At the
+     * top of the loop, search contains information about the first character
+     * in the range.
      */
 
     while (1) {
 	/*
-	 * Find the first DLine structure in the range.  Note: if the
-	 * desired character isn't the first in its text line, then look
-	 * for the character just before it instead.  This is needed to
-	 * handle the case where the first character of a wrapped
-	 * display line just got smaller, so that it now fits on the
-	 * line before:  need to relayout the line containing the
-	 * previous character.
+	 * Find the first DLine structure in the range. Note: if the desired
+	 * character isn't the first in its text line, then look for the
+	 * character just before it instead. This is needed to handle the case
+	 * where the first character of a wrapped display line just got
+	 * smaller, so that it now fits on the line before: need to relayout
+	 * the line containing the previous character.
 	 */
 
 	if (curIndexPtr->byteIndex == 0) {
@@ -4576,8 +4617,8 @@ TextRedrawTag(textPtr, index1Ptr, index2Ptr, tagPtr, withTag)
 	}
 
 	/*
-	 * Delete all of the display lines in the range, so that they'll
-	 * be re-layed out and redrawn.
+	 * Delete all of the display lines in the range, so that they'll be
+	 * re-layed out and redrawn.
 	 */
 
 	FreeDLines(textPtr, dlPtr, endPtr, DLINE_UNLINK);
@@ -4598,18 +4639,18 @@ TextRedrawTag(textPtr, index1Ptr, index2Ptr, tagPtr, withTag)
  *
  * TkTextRelayoutWindow --
  *
- *	This procedure is called when something has happened that
- *	invalidates the whole layout of characters on the screen, such
- *	as a change in a configuration option for the overall text
- *	widget or a change in the window size.  It causes all display
- *	information to be recomputed and the window to be redrawn.
+ *	This function is called when something has happened that invalidates
+ *	the whole layout of characters on the screen, such as a change in a
+ *	configuration option for the overall text widget or a change in the
+ *	window size. It causes all display information to be recomputed and
+ *	the window to be redrawn.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	All the display information will be recomputed for the window
- *	and the window will be redrawn.
+ *	All the display information will be recomputed for the window and the
+ *	window will be redrawn.
  *
  *----------------------------------------------------------------------
  */
@@ -4617,16 +4658,16 @@ TextRedrawTag(textPtr, index1Ptr, index2Ptr, tagPtr, withTag)
 void
 TkTextRelayoutWindow(textPtr, mask)
     TkText *textPtr;		/* Widget record for text widget. */
-    int mask;                   /* OR'd collection of bits showing what
-                                 * has changed */
+    int mask;			/* OR'd collection of bits showing what has
+				 * changed */
 {
     TextDInfo *dInfoPtr = textPtr->dInfoPtr;
     GC new;
     XGCValues gcValues;
 
     /*
-     * Schedule the window redisplay.  See TkTextChanged for the
-     * reason why this has to be done before any calls to FreeDLines.
+     * Schedule the window redisplay. See TkTextChanged for the reason why
+     * this has to be done before any calls to FreeDLines.
      */
 
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
@@ -4636,8 +4677,7 @@ TkTextRelayoutWindow(textPtr, mask)
 	    |REPICK_NEEDED;
 
     /*
-     * (Re-)create the graphics context for drawing the traversal
-     * highlight.
+     * (Re-)create the graphics context for drawing the traversal highlight.
      */
 
     gcValues.graphics_exposures = False;
@@ -4655,9 +4695,9 @@ TkTextRelayoutWindow(textPtr, mask)
     dInfoPtr->dLinePtr = NULL;
 
     /*
-     * Recompute some overall things for the layout.  Even if the
-     * window gets very small, pretend that there's at least one
-     * pixel of drawing space in it.
+     * Recompute some overall things for the layout. Even if the window gets
+     * very small, pretend that there's at least one pixel of drawing space in
+     * it.
      */
 
     if (textPtr->highlightWidth < 0) {
@@ -4672,9 +4712,11 @@ TkTextRelayoutWindow(textPtr, mask)
     if (dInfoPtr->maxX <= dInfoPtr->x) {
 	dInfoPtr->maxX = dInfoPtr->x + 1;
     }
-    /* 
+
+    /*
      * This is the only place where dInfoPtr->maxY is set.
      */
+
     dInfoPtr->maxY = Tk_Height(textPtr->tkwin) - textPtr->highlightWidth
 	    - textPtr->borderWidth - textPtr->padY;
     if (dInfoPtr->maxY <= dInfoPtr->y) {
@@ -4683,9 +4725,9 @@ TkTextRelayoutWindow(textPtr, mask)
     dInfoPtr->topOfEof = dInfoPtr->maxY;
 
     /*
-     * If the upper-left character isn't the first in a line, recompute
-     * it.  This is necessary because a change in the window's size
-     * or options could change the way lines wrap.
+     * If the upper-left character isn't the first in a line, recompute it.
+     * This is necessary because a change in the window's size or options
+     * could change the way lines wrap.
      */
 
     if (textPtr->topIndex.byteIndex != 0) {
@@ -4693,35 +4735,37 @@ TkTextRelayoutWindow(textPtr, mask)
     }
 
     /*
-     * Invalidate cached scrollbar positions, so that scrollbars
-     * sliders will be udpated.
+     * Invalidate cached scrollbar positions, so that scrollbars sliders will
+     * be udpated.
      */
 
     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.
+	 *
+	 * 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;
-	
-	/* 
-	 * Also cancel any partial line-height calculations (for
-	 * long-wrapped lines) in progress 
+
+	/*
+	 * Also cancel any partial line-height calculations (for long-wrapped
+	 * lines) in progress.
 	 */
+
 	dInfoPtr->metricEpoch = -1;
 
 	if (dInfoPtr->lineUpdateTimer == NULL) {
 	    textPtr->refCount++;
-	    dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(1, 
+	    dInfoPtr->lineUpdateTimer = Tcl_CreateTimerHandler(1,
 		    AsyncUpdateLineMetrics, (ClientData) textPtr);
 	}
     }
@@ -4732,16 +4776,16 @@ TkTextRelayoutWindow(textPtr, mask)
  *
  * TkTextSetYView --
  *
- *	This procedure is called to specify what lines are to be
- *	displayed in a text widget.
+ *	This function is called to specify what lines are to be displayed in
+ *	a text widget.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The display will (eventually) be updated so that the position
- *	given by "indexPtr" is visible on the screen at the position
- *	determined by "pickPlace".
+ *	The display will (eventually) be updated so that the position given by
+ *	"indexPtr" is visible on the screen at the position determined by
+ *	"pickPlace".
  *
  *----------------------------------------------------------------------
  */
@@ -4749,32 +4793,31 @@ TkTextRelayoutWindow(textPtr, mask)
 void
 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 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.  */ 
+    TkTextIndex *indexPtr;	/* Position that is to appear somewhere in the
+				 * view. */
+    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;
     int lineHeight;
-    
+
     /*
-     * If the specified position is the extra line at the end of the
-     * text, round it back to the last real line.
+     * If the specified position is the extra line at the end of the text,
+     * round it back to the last real line.
      */
 
     lineIndex = TkBTreeLinesTo(textPtr, indexPtr->linePtr);
@@ -4784,20 +4827,20 @@ TkTextSetYView(textPtr, indexPtr, pickPlace)
     }
 
     if (pickPlace == TK_TEXT_NOPIXELADJUST) {
-	if (textPtr->topIndex.linePtr == indexPtr->linePtr 
+	if (textPtr->topIndex.linePtr == indexPtr->linePtr
 	    && textPtr->topIndex.byteIndex == indexPtr->byteIndex) {
 	    pickPlace = dInfoPtr->topPixelOffset;
 	} else {
 	    pickPlace = 0;
 	}
     }
-    
+
     if (pickPlace != TK_TEXT_PICKPLACE) {
 	/*
-	 * The specified position must go at the top of the screen.
-	 * Just leave all the DLine's alone: we may be able to reuse
-	 * some of the information that's currently on the screen
-	 * without redisplaying it all.
+	 * The specified position must go at the top of the screen. Just leave
+	 * all the DLine's alone: we may be able to reuse some of the
+	 * information that's currently on the screen without redisplaying it
+	 * all.
 	 */
 
 	textPtr->topIndex = *indexPtr;
@@ -4809,10 +4852,9 @@ TkTextSetYView(textPtr, indexPtr, pickPlace)
     }
 
     /*
-     * We have to pick where to display the index.  First, bring
-     * the display information up to date and see if the index will be
-     * completely visible in the current screen configuration.  If so
-     * then there's nothing to do.
+     * We have to pick where to display the index. First, bring the display
+     * information up to date and see if the index will be completely visible
+     * in the current screen configuration. If so then there's nothing to do.
      */
 
     if (dInfoPtr->flags & DINFO_OUT_OF_DATE) {
@@ -4822,20 +4864,20 @@ TkTextSetYView(textPtr, indexPtr, pickPlace)
     if (dlPtr != NULL) {
 	if ((dlPtr->y + dlPtr->height) > dInfoPtr->maxY) {
 	    /*
-	     * Part of the line hangs off the bottom of the screen;
-	     * pretend the whole line is off-screen.
+	     * Part of the line hangs off the bottom of the screen; pretend
+	     * the whole line is off-screen.
 	     */
 
 	    dlPtr = NULL;
 	} else if ((dlPtr->index.linePtr == indexPtr->linePtr)
 		&& (dlPtr->index.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.
+	    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;
 	    }
@@ -4844,20 +4886,20 @@ 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. 
-     * 
-     * If the line is not close, place it in the center of the
-     * window.  
+     * 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.
+     *
+     * If the line is not close, place it in the center of the window.
      */
 
     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'.
+
+    /*
+     * 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*textPtr->charHeight) {
@@ -4865,15 +4907,15 @@ TkTextSetYView(textPtr, indexPtr, pickPlace)
     }
     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.  MeasureUp counts from the bottom
-	 * of the given index upwards, so we add an extra half line
-	 * to be sure we count far enough.
+	 * The desired line is above the top of screen. If it is "close" to
+	 * the top of the window then make it the top line on the screen.
+	 * MeasureUp 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 + textPtr->charHeight/2, 
+	MeasureUp(textPtr, &textPtr->topIndex, close + textPtr->charHeight/2,
 		&tmpIndex, &overlap);
 	if (TkTextIndexCmp(&tmpIndex, indexPtr) <= 0) {
 	    textPtr->topIndex = *indexPtr;
@@ -4883,13 +4925,14 @@ TkTextSetYView(textPtr, indexPtr, pickPlace)
 	}
     } 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.
+	 * 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 + lineHeight 
+	MeasureUp(textPtr, indexPtr, close + lineHeight
 		- textPtr->charHeight/2, &tmpIndex, &overlap);
 	if (FindDLine(dInfoPtr->dLinePtr, &tmpIndex) != NULL) {
 	    bottomY = dInfoPtr->maxY - dInfoPtr->y;
@@ -4897,17 +4940,17 @@ TkTextSetYView(textPtr, indexPtr, pickPlace)
     }
 
     /*
-     * Our job now is to arrange the display so that indexPtr appears
-     * as low on the screen as possible but with its bottom no lower
-     * than bottomY.  BottomY is the bottom of the window if the
-     * desired line is just below the current screen, otherwise it
-     * is a half-line lower than the center of the window.
+     * Our job now is to arrange the display so that indexPtr appears as low
+     * on the screen as possible but with its bottom no lower than bottomY.
+     * BottomY is the bottom of the window if the desired line is just below
+     * the current screen, otherwise it is 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:
+  scheduleUpdate:
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
 	Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr);
     }
@@ -4919,14 +4962,13 @@ TkTextSetYView(textPtr, indexPtr, pickPlace)
  *
  * 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 below the top of the given index.
+ *	Given one index, find the index of the first character on the highest
+ *	display line that would be displayed no more 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.
+ *	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.
@@ -4939,16 +4981,15 @@ 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. */
+    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->sharedTextPtr->tree, textPtr, 
-			TkBTreeNumLines(textPtr->sharedTextPtr->tree, textPtr));
+    lastLinePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree, textPtr,
+	    TkBTreeNumLines(textPtr->sharedTextPtr->tree, textPtr));
 
     do {
 	dlPtr = LayoutDLine(textPtr, srcPtr);
@@ -4975,23 +5016,22 @@ TkTextMeasureDown(textPtr, srcPtr, 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.
+ *	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
- *	on a display line.  The display line is found by measuring
- *	up "distance" pixels above the pixel just below an imaginary
- *	display line that contains srcPtr.  If the display line
- *	that covers this coordinate actually extends above the 
- *	coordinate, then return any excess pixels in *overlap, if
- *	that is non-NULL.
+ *	*dstPtr is filled in with the index of the first character on a
+ *	display line. The display line is found by measuring up "distance"
+ *	pixels above the pixel just below an imaginary display line that
+ *	contains srcPtr. If the display line that covers this coordinate
+ *	actually extends above the coordinate, then return any excess pixels
+ *	in *overlap, if that is non-NULL.
  *
  * Side effects:
  *	None.
@@ -5004,13 +5044,12 @@ MeasureUp(textPtr, srcPtr, distance, dstPtr, overlap)
     TkText *textPtr;		/* Text widget in which to measure. */
     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. */
+    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 *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
@@ -5024,12 +5063,11 @@ MeasureUp(textPtr, srcPtr, distance, dstPtr, overlap)
 	    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
-	 * in backwards order (the lowest DLine on the screen is first
-	 * in the list).
+	 *
+	 * 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 in backwards order (the lowest
+	 * DLine on the screen is first in the list).
 	 */
 
 	index.linePtr = TkBTreeFindLine(srcPtr->tree, textPtr, lineNum);
@@ -5045,10 +5083,10 @@ MeasureUp(textPtr, srcPtr, distance, dstPtr, overlap)
 
 	/*
 	 * 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.  If distance was zero to start
-	 * with then we simply get the first index on the same display
-	 * line as the original index.
+	 * vertical distance. If so, save the starting index for the 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) {
@@ -5063,8 +5101,8 @@ MeasureUp(textPtr, srcPtr, distance, dstPtr, overlap)
 	}
 
 	/*
-	 * Discard the display lines, then either return or prepare
-	 * for the next display line to lay out.
+	 * Discard the display lines, then either return or prepare for the
+	 * next display line to lay out.
 	 */
 
 	FreeDLines(textPtr, lowestPtr, (DLine *) NULL, DLINE_FREE);
@@ -5075,13 +5113,13 @@ MeasureUp(textPtr, srcPtr, distance, dstPtr, overlap)
     }
 
     /*
-     * Ran off the beginning of the text.  Return the first character
-     * in the text.
+     * Ran off the beginning of the text. Return the first character in the
+     * text.
      */
 
     TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr, 0, 0, dstPtr);
     if (overlap != NULL) {
-        *overlap = 0;
+	*overlap = 0;
     }
 }
 
@@ -5090,9 +5128,9 @@ MeasureUp(textPtr, srcPtr, distance, dstPtr, overlap)
  *
  * TkTextSeeCmd --
  *
- *	This procedure is invoked to process the "see" option for
- *	the widget command for text widgets. See the user documentation
- *	for details on what it does.
+ *	This function is invoked to process the "see" option for the widget
+ *	command for text widgets. See the user documentation for details on
+ *	what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -5127,12 +5165,12 @@ TkTextSeeCmd(textPtr, interp, objc, objv)
     }
 
     /*
-     * If the specified position is the extra line at the end of the
-     * text, round it back to the last real line.
+     * If the specified position is the extra line at the end of the text,
+     * round it back to the last real line.
      */
 
-    if (TkBTreeLinesTo(textPtr, index.linePtr) 
-      == TkBTreeNumLines(index.tree, textPtr)) {
+    if (TkBTreeLinesTo(textPtr, index.linePtr)
+	    == TkBTreeNumLines(index.tree, textPtr)) {
 	TkTextIndexBackChars(textPtr, &index, 1, &index, COUNT_INDICES);
     }
 
@@ -5155,8 +5193,8 @@ TkTextSeeCmd(textPtr, interp, objc, objv)
     }
 
     /*
-     * Find the chunk that contains the desired index.
-     * dlPtr may be NULL if the widget is not mapped. [Bug #641778]
+     * Find the chunk that contains the desired index. dlPtr may be NULL if
+     * the widget is not mapped. [Bug #641778]
      */
 
     dlPtr = FindDLine(dInfoPtr->dLinePtr, &index);
@@ -5174,9 +5212,9 @@ TkTextSeeCmd(textPtr, interp, objc, objv)
     }
 
     /*
-     * Call a chunk-specific procedure to find the horizontal range of
-     * the character within the chunk.
-     * chunkPtr is NULL if trying to see in elided region.
+     * Call a chunk-specific function to find the horizontal range of the
+     * character within the chunk. chunkPtr is NULL if trying to see in elided
+     * region.
      */
 
     if (chunkPtr != NULL) {
@@ -5219,9 +5257,9 @@ TkTextSeeCmd(textPtr, interp, objc, objv)
  *
  * TkTextXviewCmd --
  *
- *	This procedure is invoked to process the "xview" option for
- *	the widget command for text widgets. See the user documentation
- *	for details on what it does.
+ *	This function is invoked to process the "xview" option for the widget
+ *	command for text widgets. See the user documentation for details on
+ *	what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -5254,36 +5292,36 @@ TkTextXviewCmd(textPtr, interp, objc, objv)
 	return TCL_OK;
     }
 
-    type = TextGetScrollInfoObj(interp, textPtr, objc, objv, 
-				&fraction, &count);
+    type = TextGetScrollInfoObj(interp, textPtr, objc, objv,
+	    &fraction, &count);
     switch (type) {
-	case TKTEXT_SCROLL_ERROR:
-	    return TCL_ERROR;
-	case TKTEXT_SCROLL_MOVETO:
-	    if (fraction > 1.0) {
-		fraction = 1.0;
-	    }
-	    if (fraction < 0) {
-		fraction = 0;
-	    }
-	    dInfoPtr->newXPixelOffset = (int) (fraction 
-					       * dInfoPtr->maxLength + 0.5);
-	    break;
-	case TKTEXT_SCROLL_PAGES: {
-	    int pixelsPerPage;
-	    pixelsPerPage = (dInfoPtr->maxX-dInfoPtr->x) - 2*textPtr->charWidth;
-	    if (pixelsPerPage < 1) {
-		pixelsPerPage = 1;
-	    }
-	    dInfoPtr->newXPixelOffset += pixelsPerPage * count;
-	    break;
+    case TKTEXT_SCROLL_ERROR:
+	return TCL_ERROR;
+    case TKTEXT_SCROLL_MOVETO:
+	if (fraction > 1.0) {
+	    fraction = 1.0;
 	}
-	case TKTEXT_SCROLL_UNITS:
-	    dInfoPtr->newXPixelOffset += count * textPtr->charWidth;
-	    break;
-	case TKTEXT_SCROLL_PIXELS:
-	    dInfoPtr->newXPixelOffset += count;
-	    break;
+	if (fraction < 0) {
+	    fraction = 0;
+	}
+	dInfoPtr->newXPixelOffset = (int)
+		(fraction * dInfoPtr->maxLength + 0.5);
+	break;
+    case TKTEXT_SCROLL_PAGES: {
+	int pixelsPerPage;
+	pixelsPerPage = (dInfoPtr->maxX-dInfoPtr->x) - 2*textPtr->charWidth;
+	if (pixelsPerPage < 1) {
+	    pixelsPerPage = 1;
+	}
+	dInfoPtr->newXPixelOffset += pixelsPerPage * count;
+	break;
+    }
+    case TKTEXT_SCROLL_UNITS:
+	dInfoPtr->newXPixelOffset += count * textPtr->charWidth;
+	break;
+    case TKTEXT_SCROLL_PIXELS:
+	dInfoPtr->newXPixelOffset += count;
+	break;
     }
 
     dInfoPtr->flags |= DINFO_OUT_OF_DATE;
@@ -5299,8 +5337,8 @@ TkTextXviewCmd(textPtr, interp, objc, objv)
  *
  * YScrollByPixels --
  *
- *	This procedure is called to scroll a text widget up or down
- *	by a given number of pixels.
+ *	This function is called to scroll a text widget up or down by a given
+ *	number of pixels.
  *
  * Results:
  *	None.
@@ -5315,33 +5353,33 @@ TkTextXviewCmd(textPtr, interp, objc, objv)
 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. */
+    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.
+	/*
+	 * 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 -= CalculateDisplayLineHeight(textPtr, 
+
+	offset -= CalculateDisplayLineHeight(textPtr,
 		&textPtr->topIndex, NULL, NULL) - dInfoPtr->topPixelOffset;
-	MeasureUp(textPtr, &textPtr->topIndex, -offset, 
+	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.
+	 * Scrolling down by pixels. Layout lines starting at the top index
+	 * and count through the desired vertical distance.
 	 */
 
 	lastLinePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree, textPtr,
@@ -5351,10 +5389,13 @@ YScrollByPixels(textPtr, offset)
 	while (offset > 0) {
 	    dlPtr = LayoutDLine(textPtr, &textPtr->topIndex);
 	    dlPtr->nextPtr = NULL;
-	    TkTextIndexForwBytes(textPtr, &textPtr->topIndex, 
-				 dlPtr->byteCount, &new);
+	    TkTextIndexForwBytes(textPtr, &textPtr->topIndex,
+		    dlPtr->byteCount, &new);
 	    if (offset <= dlPtr->height) {
-		/* Adjust the top overlap accordingly */
+		/*
+		 * Adjust the top overlap accordingly.
+		 */
+
 		dInfoPtr->newTopPixelOffset = offset;
 	    }
 	    offset -= dlPtr->height;
@@ -5365,7 +5406,10 @@ YScrollByPixels(textPtr, offset)
 	    textPtr->topIndex = new;
 	}
     } else {
-	/* offset = 0, so no scrolling required */
+	/*
+	 * offset = 0, so no scrolling required.
+	 */
+
 	return;
     }
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
@@ -5379,15 +5423,14 @@ YScrollByPixels(textPtr, offset)
  *
  * YScrollByLines --
  *
- *	This procedure is called to scroll a text widget up or down
- *	by a given number of lines.
+ *	This function is called to scroll a text widget up or down by a given
+ *	number of lines.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The view in textPtr's window changes to reflect the value
- *	of "offset".
+ *	The view in textPtr's window changes to reflect the value of "offset".
  *
  *----------------------------------------------------------------------
  */
@@ -5395,11 +5438,11 @@ YScrollByPixels(textPtr, offset)
 static void
 YScrollByLines(textPtr, offset)
     TkText *textPtr;		/* Widget to scroll. */
-    int offset;			/* Amount by which to scroll, in display 
-				 * lines.  Positive means that information
+    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
-				 * text becomes visible. */
+				 * means that information earlier in the text
+				 * becomes visible. */
 {
     int i, bytesToCount, lineNum;
     TkTextIndex new, index;
@@ -5409,25 +5452,25 @@ YScrollByLines(textPtr, offset)
 
     if (offset < 0) {
 	/*
-	 * Must scroll up (to show earlier information in the text).
-	 * The code below is similar to that in MeasureUp, except that
-	 * it counts lines instead of pixels.
+	 * Must scroll up (to show earlier information in the text). The code
+	 * below is similar to that in MeasureUp, except that it counts lines
+	 * instead of pixels.
 	 */
 
 	bytesToCount = textPtr->topIndex.byteIndex + 1;
 	index.tree = textPtr->sharedTextPtr->tree;
-	offset--;			/* Skip line containing topIndex. */
+	offset--;		/* Skip line containing topIndex. */
 	for (lineNum = TkBTreeLinesTo(textPtr, textPtr->topIndex.linePtr);
 		lineNum >= 0; lineNum--) {
-	    index.linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree, 
-					    textPtr, lineNum);
+	    index.linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree,
+		    textPtr, lineNum);
 	    index.byteIndex = 0;
 	    lowestPtr = NULL;
 	    do {
 		dlPtr = LayoutDLine(textPtr, &index);
 		dlPtr->nextPtr = lowestPtr;
 		lowestPtr = dlPtr;
-		TkTextIndexForwBytes(textPtr, &index, dlPtr->byteCount, &index);
+		TkTextIndexForwBytes(textPtr, &index, dlPtr->byteCount,&index);
 		bytesToCount -= dlPtr->byteCount;
 	    } while ((bytesToCount > 0)
 		    && (index.linePtr == dlPtr->index.linePtr));
@@ -5441,40 +5484,42 @@ YScrollByLines(textPtr, offset)
 	    }
 
 	    /*
-	     * Discard the display lines, then either return or prepare
-	     * for the next display line to lay out.
+	     * Discard the display lines, then either return or prepare for
+	     * the next display line to lay out.
 	     */
-    
+
 	    FreeDLines(textPtr, lowestPtr, (DLine *) NULL, DLINE_FREE);
 	    if (offset >= 0) {
 		goto scheduleUpdate;
 	    }
 	    bytesToCount = INT_MAX;
 	}
-    
+
 	/*
-	 * Ran off the beginning of the text.  Return the first character
-	 * in the text, and make sure we haven't left anything
-	 * overlapping the top window border.
+	 * Ran off the beginning of the text. Return the first character in
+	 * the text, and make sure we haven't left anything overlapping the
+	 * top window border.
 	 */
 
-	TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr, 
+	TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr,
 			    0, 0, &textPtr->topIndex);
 	dInfoPtr->newTopPixelOffset = 0;
     } else {
 	/*
-	 * Scrolling down, to show later information in the text.
-	 * Just count lines from the current top of the window.
+	 * Scrolling down, to show later information in the text. Just count
+	 * lines from the current top of the window.
 	 */
 
 	lastLinePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree, textPtr,
 		TkBTreeNumLines(textPtr->sharedTextPtr->tree, textPtr));
 	for (i = 0; i < offset; i++) {
 	    dlPtr = LayoutDLine(textPtr, &textPtr->topIndex);
-	    if (dlPtr->length == 0 && dlPtr->height == 0) offset++;
+	    if (dlPtr->length == 0 && dlPtr->height == 0) {
+		offset++;
+	    }
 	    dlPtr->nextPtr = NULL;
-	    TkTextIndexForwBytes(textPtr, &textPtr->topIndex, 
-				 dlPtr->byteCount, &new);
+	    TkTextIndexForwBytes(textPtr, &textPtr->topIndex,
+		    dlPtr->byteCount, &new);
 	    FreeDLines(textPtr, dlPtr, (DLine *) NULL, DLINE_FREE);
 	    if (new.linePtr == lastLinePtr) {
 		break;
@@ -5483,7 +5528,7 @@ YScrollByLines(textPtr, offset)
 	}
     }
 
-    scheduleUpdate:
+  scheduleUpdate:
     if (!(dInfoPtr->flags & REDRAW_PENDING)) {
 	Tcl_DoWhenIdle(DisplayText, (ClientData) textPtr);
     }
@@ -5495,9 +5540,9 @@ YScrollByLines(textPtr, offset)
  *
  * TkTextYviewCmd --
  *
- *	This procedure is invoked to process the "yview" option for
- *	the widget command for text widgets. See the user documentation
- *	for details on what it does.
+ *	This function is invoked to process the "yview" option for the widget
+ *	command for text widgets. See the user documentation for details on
+ *	what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -5541,7 +5586,7 @@ 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]), 
+		&& (strncmp(Tcl_GetString(objv[2]),
 			"-pickplace", switchLength) == 0)) {
 	    pickPlace = 1;
 	    if (objc != 4) {
@@ -5553,16 +5598,16 @@ TkTextYviewCmd(textPtr, interp, objc, objv)
     if ((objc == 3) || pickPlace) {
 	int lineNum;
 	if (Tcl_GetIntFromObj(interp, objv[2+pickPlace], &lineNum) == TCL_OK) {
-	    TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr, 
+	    TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr,
 				lineNum, 0, &index);
 	    TkTextSetYView(textPtr, &index, 0);
 	    return TCL_OK;
 	}
-    
+
 	/*
 	 * The argument must be a regular text index.
 	 */
-    
+
 	Tcl_ResetResult(interp);
 	if (TkTextGetObjIndex(interp, textPtr, objv[2+pickPlace],
 		&index) != TCL_OK) {
@@ -5578,86 +5623,92 @@ TkTextYviewCmd(textPtr, interp, objc, objv)
 
     type = TextGetScrollInfoObj(interp, textPtr, objc,objv, &fraction, &count);
     switch (type) {
-	case TKTEXT_SCROLL_ERROR:
-	    return TCL_ERROR;
-	case TKTEXT_SCROLL_MOVETO: {
-	    int numPixels = TkBTreeNumPixels(textPtr->sharedTextPtr->tree,
-					     textPtr);
-	    int topMostPixel;
-	    if (numPixels == 0) {
-		/* 
-		 * If the window is totally empty no scrolling is
-		 * needed, and the TkTextMakePixelIndex call
-		 * below will fail.
-		 */
-		break;
-	    }
-	    if (fraction > 1.0) {
-		fraction = 1.0;
-	    }
-	    if (fraction < 0) {
-		fraction = 0;
-	    }
-	    /* 
-	     * Calculate the pixel count for the new topmost pixel
-	     * in the topmost line of the window.  Note that the
-	     * interpretation of 'fraction' is that it counts from
-	     * 0 (top pixel in buffer) to 1.0 (one pixel past the
-	     * last pixel in buffer).
-	     */
-	    topMostPixel = (int) (0.5 + fraction * numPixels);
-	    if (topMostPixel >= numPixels) {
-		topMostPixel = numPixels -1;
-	    }
+    case TKTEXT_SCROLL_ERROR:
+	return TCL_ERROR;
+    case TKTEXT_SCROLL_MOVETO: {
+	int numPixels = TkBTreeNumPixels(textPtr->sharedTextPtr->tree,
+		textPtr);
+	int topMostPixel;
+
+	if (numPixels == 0) {
 	    /*
-	     * 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.
+	     * If the window is totally empty no scrolling is needed, and the
+	     * TkTextMakePixelIndex call below will fail.
 	     */
-	    pixels = TkTextMakePixelIndex(textPtr, topMostPixel, &index);
-	    TkTextSetYView(textPtr, &index, pixels);
+
 	    break;
 	}
-	case TKTEXT_SCROLL_PAGES: {
+	if (fraction > 1.0) {
+	    fraction = 1.0;
+	}
+	if (fraction < 0) {
+	    fraction = 0;
+	}
+
+	/*
+	 * Calculate the pixel count for the new topmost pixel in the topmost
+	 * line of the window. Note that the interpretation of 'fraction' is
+	 * that it counts from 0 (top pixel in buffer) to 1.0 (one pixel past
+	 * the last pixel in buffer).
+	 */
+
+	topMostPixel = (int) (0.5 + fraction * numPixels);
+	if (topMostPixel >= numPixels) {
+	    topMostPixel = numPixels -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, topMostPixel, &index);
+	TkTextSetYView(textPtr, &index, pixels);
+	break;
+    }
+    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.
+	 */
+
+	int height = dInfoPtr->maxY - dInfoPtr->y;
+	if (textPtr->charHeight * 4 >= height) {
 	    /*
-	     * Scroll up or down by screenfuls.  Actually, use the
-	     * window height minus two lines, so that there's some
-	     * overlap between adjacent pages.
+	     * A single line is more than a quarter of the display. We choose
+	     * to scroll by 3/4 of the height instead.
 	     */
-	    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.
 		 */
-		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.
-		     */
-		    if (textPtr->charHeight < height) {
-			pixels = textPtr->charHeight;
-		    } else {
-			pixels = height;
-		    }
+
+		if (textPtr->charHeight < height) {
+		    pixels = textPtr->charHeight;
+		} else {
+		    pixels = height;
 		}
-		pixels *= count;
-	    } else {
-		pixels = (height - 2*textPtr->charHeight)*count;
 	    }
-	    YScrollByPixels(textPtr, pixels);
-	    break;
+	    pixels *= count;
+	} else {
+	    pixels = (height - 2*textPtr->charHeight)*count;
 	}
-	case TKTEXT_SCROLL_PIXELS:
-	    YScrollByPixels(textPtr, count);
-	    break;
-	case TKTEXT_SCROLL_UNITS:
-	    YScrollByLines(textPtr, count);
-	    break;
+	YScrollByPixels(textPtr, pixels);
+	break;
+    }
+    case TKTEXT_SCROLL_PIXELS:
+	YScrollByPixels(textPtr, count);
+	break;
+    case TKTEXT_SCROLL_UNITS:
+	YScrollByLines(textPtr, count);
+	break;
     }
     return TCL_OK;
 }
@@ -5667,9 +5718,9 @@ TkTextYviewCmd(textPtr, interp, objc, objv)
  *
  * TkTextScanCmd --
  *
- *	This procedure is invoked to process the "scan" option for
- *	the widget command for text widgets. See the user documentation
- *	for details on what it does.
+ *	This function is invoked to process the "scan" option for the widget
+ *	command for text widgets. See the user documentation for details on
+ *	what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -5697,7 +5748,7 @@ TkTextScanCmd(textPtr, interp, objc, objv)
     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?\"", 
+		Tcl_GetString(objv[0]), " scan dragto x y ?gain?\"",
 		(char *) NULL);
 	return TCL_ERROR;
     }
@@ -5708,23 +5759,22 @@ TkTextScanCmd(textPtr, interp, objc, objv)
 	return TCL_ERROR;
     }
     if ((objc == 6) && (Tcl_GetIntFromObj(interp, objv[5], &gain) != TCL_OK)) {
-        return TCL_ERROR;
+	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) {
 	int newX, maxX;
-	
+
 	/*
-	 * Amplify the difference between the current position and the
-	 * mark position to compute how much the view should shift, then
-	 * update the mark position to correspond to the new view.  If we
-	 * run off the edge of the text, reset the mark point so that the
-	 * current position continues to correspond to the edge of the
-	 * window.  This means that the picture will start dragging as
-	 * soon as the mouse reverses direction (without this reset, might
-	 * have to slide mouse a long ways back before the picture starts
-	 * moving again).
+	 * Amplify the difference between the current position and the mark
+	 * position to compute how much the view should shift, then update the
+	 * mark position to correspond to the new view. If we run off the edge
+	 * of the text, reset the mark point so that the current position
+	 * continues to correspond to the edge of the window. This means that
+	 * the picture will start dragging as soon as the mouse reverses
+	 * direction (without this reset, might have to slide mouse a long
+	 * ways back before the picture starts moving again).
 	 */
 
 	newX = dInfoPtr->scanMarkXPixel + gain*(dInfoPtr->scanMarkX - x);
@@ -5774,19 +5824,19 @@ TkTextScanCmd(textPtr, interp, objc, objv)
  *
  * GetXView --
  *
- *	This procedure computes the fractions that indicate what's
- *	visible in a text window and, optionally, evaluates a
- *	Tcl script to report them to the text's associated scrollbar.
+ *	This function computes the fractions that indicate what's visible in a
+ *	text window and, optionally, evaluates a Tcl script to report them to
+ *	the text's associated scrollbar.
  *
  * Results:
- *	If report is zero, then the interp's result is filled in with
- *	two real numbers separated by a space, giving the position of
- *	the left and right edges of the window as fractions from 0 to
- *	1, where 0 means the left edge of the text and 1 means the right
- *	edge.  If report is non-zero, then the interp's result isn't modified
- *	directly, but instead a script is evaluated in interp to report
- *	the new horizontal scroll position to the scrollbar (if the scroll
- *	position hasn't changed then no script is invoked).
+ *	If report is zero, then the interp's result is filled in with two real
+ *	numbers separated by a space, giving the position of the left and
+ *	right edges of the window as fractions from 0 to 1, where 0 means the
+ *	left edge of the text and 1 means the right edge. If report is
+ *	non-zero, then the interp's result isn't modified directly, but
+ *	instead a script is evaluated in interp to report the new horizontal
+ *	scroll position to the scrollbar (if the scroll position hasn't
+ *	changed then no script is invoked).
  *
  * Side effects:
  *	None.
@@ -5796,18 +5846,18 @@ TkTextScanCmd(textPtr, interp, objc, objv)
 
 static void
 GetXView(interp, textPtr, report)
-    Tcl_Interp *interp;			/* If "report" is FALSE, string
-					 * describing visible range gets
-					 * stored in the interp's result. */
-    TkText *textPtr;			/* Information about text widget. */
-    int report;				/* Non-zero means report info to
-					 * scrollbar if it has changed. */
+    Tcl_Interp *interp;		/* If "report" is FALSE, string describing
+				 * visible range gets stored in the interp's
+				 * result. */
+    TkText *textPtr;		/* Information about text widget. */
+    int report;			/* Non-zero means report info to scrollbar if
+				 * it has changed. */
 {
     TextDInfo *dInfoPtr = textPtr->dInfoPtr;
     double first, last;
     int code;
     Tcl_Obj *listObj;
-    
+
     if (dInfoPtr->maxLength > 0) {
 	first = ((double) dInfoPtr->curXPixelOffset)
 		/ dInfoPtr->maxLength;
@@ -5828,7 +5878,7 @@ GetXView(interp, textPtr, report)
 	return;
     }
     if (FP_EQUAL_SCALE(first, dInfoPtr->xScrollFirst, dInfoPtr->maxLength) &&
-	FP_EQUAL_SCALE(last,  dInfoPtr->xScrollLast,  dInfoPtr->maxLength)) {
+	    FP_EQUAL_SCALE(last, dInfoPtr->xScrollLast, dInfoPtr->maxLength)) {
 	return;
     }
     dInfoPtr->xScrollFirst = first;
@@ -5836,6 +5886,7 @@ GetXView(interp, textPtr, report)
     if (textPtr->xScrollCmd != NULL) {
 	char buf1[TCL_DOUBLE_SPACE+1];
 	char buf2[TCL_DOUBLE_SPACE+1];
+
 	buf1[0] = ' ';
 	buf2[0] = ' ';
 	Tcl_PrintDouble(NULL, first, buf1+1);
@@ -5843,7 +5894,7 @@ GetXView(interp, textPtr, report)
 	code = Tcl_VarEval(interp, textPtr->xScrollCmd, buf1, buf2, NULL);
 	if (code != TCL_OK) {
 	    Tcl_AddErrorInfo(interp,
-		"\n    (horizontal scrolling command executed by text)");
+		    "\n    (horizontal scrolling command executed by text)");
 	    Tcl_BackgroundError(interp);
 	}
     }
@@ -5854,90 +5905,93 @@ GetXView(interp, textPtr, report)
  *
  * GetYPixelCount --
  *
- *	How many pixels are there between the absolute top of the
- *	widget and the top of the given DLine.
- *	
- *	While this function will work for any valid DLine, it is
- *	only ever called when dlPtr is the first display
- *	line in the widget (by 'GetYView').  This means that
- *	usually this function is a very quick calculation, since
- *	it can use the pre-calculated linked-list of DLines for
- *	height information.
- *	
- *	The only situation where this breaks down is if dlPtr's logical
- *	line wraps enough times to fill the text widget's current view
- *	-- in this case we won't have enough dlPtrs in the linked list
- *	to be able to subtract off what we want.
+ *	How many pixels are there between the absolute top of the widget and
+ *	the top of the given DLine.
+ *
+ *	While this function will work for any valid DLine, it is only ever
+ *	called when dlPtr is the first display line in the widget (by
+ *	'GetYView'). This means that usually this function is a very quick
+ *	calculation, since it can use the pre-calculated linked-list of DLines
+ *	for height information.
+ *
+ *	The only situation where this breaks down is if dlPtr's logical line
+ *	wraps enough times to fill the text widget's current view - in this
+ *	case we won't have enough dlPtrs in the linked list to be able to
+ *	subtract off what we want.
  *
  * Results:
  *	The number of pixels.
- *	
- *	This value has a valid range between '0' (the very top of the
- *	widget) and the number of pixels in the total widget minus the
- *	pixel-height of the last line.
+ *
+ *	This value has a valid range between '0' (the very top of the widget)
+ *	and the number of pixels in the total widget minus the pixel-height of
+ *	the last line.
  *
  * Side effects:
  *	None.
  *
  *----------------------------------------------------------------------
  */
-    
+
 static int
 GetYPixelCount(textPtr, dlPtr)
-    TkText *textPtr;			/* Information about text widget. */
-    DLine *dlPtr;                       /* Information about the layout
-                                         * of a given index */
+    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 to the top of dlPtr's logical line.  The
-     * rest of the function is then concerned with updating 'count'
-     * for any difference between the top of the logical line and
-     * the display line.
+
+    /*
+     * Get the pixel count to the top of dlPtr's logical line. The rest of the
+     * function is then concerned with updating 'count' for any difference
+     * between the top of the logical line and the display line.
      */
+
     int count = TkBTreePixelsTo(textPtr, linePtr);
-   
-    /* 
-     * For the common case where this dlPtr is also the start of the
-     * logical line, we can return right away.  Note the implicit
-     * assumption here that the start of a logical line is always the
-     * start of a display line (if the 'elide won't elide first newline'
-     * bug is fixed, this will no longer necessarily be true).
+
+    /*
+     * For the common case where this dlPtr is also the start of the logical
+     * line, we can return right away. Note the implicit assumption here that
+     * the start of a logical line is always the start of a display line (if
+     * the 'elide won't elide first newline' bug is fixed, this will no longer
+     * necessarily be true).
      */
+
     if (dlPtr->index.byteIndex == 0) {
-        return count;
-    }
-
-    /* 
-     * Add on the logical line's height to reach one pixel beyond the
-     * bottom of the logical line.  And then subtract off the heights of
-     * all the display lines from dlPtr to the end of its logical line.
-     * 
-     * A different approach would be to lay things out from the start of
-     * the logical line until we reach dlPtr, but since none of those are
-     * pre-calculated, it'll usually take a lot longer.  (But there are
-     * cases where it would be more efficient: say if we're on the second
-     * of 1000 wrapped lines all from a single logical line -- but that
-     * sort of optimization is left for the future).
+	return count;
+    }
+
+    /*
+     * Add on the logical line's height to reach one pixel beyond the bottom
+     * of the logical line. And then subtract off the heights of all the
+     * display lines from dlPtr to the end of its logical line.
+     *
+     * A different approach would be to lay things out from the start of the
+     * logical line until we reach dlPtr, but since none of those are
+     * pre-calculated, it'll usually take a lot longer. (But there are cases
+     * where it would be more efficient: say if we're on the second of 1000
+     * wrapped lines all from a single logical line - but that sort of
+     * optimization is left for the future).
      */
+
     count += TkBTreeLinePixelCount(textPtr, linePtr);
 
     do {
 	count -= dlPtr->height;
 	if (dlPtr->nextPtr == NULL) {
-	    /* 
-	     * We've run out of pre-calculated display lines, so we
-	     * have to lay them out ourselves until the end of the
-	     * logical line.  Here's where we could be clever and ask:
-	     * what's faster, to layout all lines from here to line-end,
-	     * or all lines from the original dlPtr to the line-start?
-	     * We just assume the former.
+	    /*
+	     * We've run out of pre-calculated display lines, so we have to
+	     * lay them out ourselves until the end of the logical line.
+	     * Here's where we could be clever and ask: what's faster, to
+	     * layout all lines from here to line-end, or all lines from the
+	     * original dlPtr to the line-start? We just assume the former.
 	     */
+
 	    TkTextIndex index;
 	    int notFirst = 0;
+
 	    while (1) {
-		TkTextIndexForwBytes(textPtr, &dlPtr->index, 
-				     dlPtr->byteCount, &index);
+		TkTextIndexForwBytes(textPtr, &dlPtr->index,
+			dlPtr->byteCount, &index);
 		if (notFirst) {
 		    FreeDLines(textPtr, dlPtr, (DLine *)NULL, DLINE_FREE_TEMP);
 		}
@@ -5945,18 +5999,18 @@ GetYPixelCount(textPtr, dlPtr)
 		    break;
 		}
 		dlPtr = LayoutDLine(textPtr, &index);
-		
+
 		if (tkTextDebug) {
 		    char string[TK_POS_CHARS];
 
 		    /*
-		     * Debugging is enabled, so keep a log of all the
-		     * lines whose height was recalculated.  The test
-		     * suite uses this information.
+		     * Debugging is enabled, so keep a log of all the lines
+		     * whose height was recalculated. The test suite uses this
+		     * information.
 		     */
 
 		    TkTextPrintIndex(textPtr, &index, string);
-		    Tcl_SetVar2(textPtr->interp, "tk_textHeightCalc", 
+		    Tcl_SetVar2(textPtr->interp, "tk_textHeightCalc",
 			    (char *) NULL, string,
 			    TCL_GLOBAL_ONLY|TCL_APPEND_VALUE|TCL_LIST_ELEMENT);
 		}
@@ -5968,7 +6022,7 @@ GetYPixelCount(textPtr, dlPtr)
 	    dlPtr = dlPtr->nextPtr;
 	}
     } while (dlPtr->index.linePtr == linePtr);
-    
+
     return count;
 }
 
@@ -5977,69 +6031,68 @@ GetYPixelCount(textPtr, dlPtr)
  *
  * GetYView --
  *
- *	This procedure computes the fractions that indicate what's
- *	visible in a text window and, optionally, evaluates a
- *	Tcl script to report them to the text's associated scrollbar.
+ *	This function computes the fractions that indicate what's visible in
+ *	a text window and, optionally, evaluates a Tcl script to report them
+ *	to the text's associated scrollbar.
  *
  * Results:
- *	If report is zero, then the interp's result is filled in with
- *	two real numbers separated by a space, giving the position of
- *	the top and bottom of the window as fractions from 0 to 1, where
- *	0 means the beginning of the text and 1 means the end.  If
- *	report is non-zero, then the interp's result isn't modified directly,
- *	but a script is evaluated in interp to report the new scroll
- *	position to the scrollbar (if the scroll position hasn't changed
- *	then no script is invoked).
+ *	If report is zero, then the interp's result is filled in with two real
+ *	numbers separated by a space, giving the position of the top and
+ *	bottom of the window as fractions from 0 to 1, where 0 means the
+ *	beginning of the text and 1 means the end. If report is non-zero, then
+ *	the interp's result isn't modified directly, but a script is evaluated
+ *	in interp to report the new scroll position to the scrollbar (if the
+ *	scroll position hasn't changed then no script is invoked).
  *
  * Side effects:
  *	None.
  *
  *----------------------------------------------------------------------
  */
-    
+
 static void
 GetYView(interp, textPtr, report)
-    Tcl_Interp *interp;			/* If "report" is FALSE, string
-					 * describing visible range gets
-					 * stored in the interp's result. */
-    TkText *textPtr;			/* Information about text widget. */
-    int report;				/* Non-zero means report info to
-					 * scrollbar if it has changed. */
+    Tcl_Interp *interp;		/* If "report" is FALSE, string describing
+				 * visible range gets stored in the interp's
+				 * result. */
+    TkText *textPtr;		/* Information about text widget. */
+    int report;			/* Non-zero means report info to scrollbar if
+				 * it has changed. */
 {
     TextDInfo *dInfoPtr = textPtr->dInfoPtr;
     double first, last;
     DLine *dlPtr;
     int totalPixels, code, count;
     Tcl_Obj *listObj;
-    
+
     dlPtr = dInfoPtr->dLinePtr;
 
     if (dlPtr == NULL) {
 	return;
     }
 
-    totalPixels = TkBTreeNumPixels(textPtr->sharedTextPtr->tree,
-				   textPtr);
-    
+    totalPixels = TkBTreeNumPixels(textPtr->sharedTextPtr->tree, textPtr);
+
     if (totalPixels == 0) {
 	first = 0.0;
 	last = 1.0;
     } else {
-	/* 
-	 * Get the pixel count for the first visible pixel of the
-	 * first visible line.  If the first visible line is only
-	 * partially visible, then we use 'topPixelOffset' to get the
-	 * difference.
+	/*
+	 * Get the pixel count for the first 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 = GetYPixelCount(textPtr, dlPtr);
 	first = (count + dInfoPtr->topPixelOffset) / (double) totalPixels;
 
-	/* 
-	 * Add on the total number of visible pixels to get the count to
-	 * one pixel _past_ the last visible pixel.  This is how the
-	 * 'yview' command is documented, and also explains why we are
-	 * dividing by 'totalPixels' and not 'totalPixels-1'.
+	/*
+	 * Add on the total number of visible pixels to get the count to one
+	 * pixel _past_ the last visible pixel. This is how the 'yview'
+	 * command is documented, and also explains why we are dividing by
+	 * 'totalPixels' and not 'totalPixels-1'.
 	 */
+
 	while (1) {
 	    int extra;
 	    count += dlPtr->height;
@@ -6047,10 +6100,11 @@ GetYView(interp, textPtr, report)
 	    extra = dlPtr->y + dlPtr->height - dInfoPtr->maxY;
 	    if (extra > 0) {
 		/*
-		 * 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.
+		 * 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 -= extra;
 		break;
 	    }
@@ -6059,42 +6113,42 @@ GetYView(interp, textPtr, report)
 	    }
 	    dlPtr = dlPtr->nextPtr;
 	}
-	
+
 	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.
+	    /*
+	     * 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
+
+#if 0
 	    Tcl_Panic("Counted more pixels (%d) than expected (%d) total "
 		    "pixels in text widget scroll bar calculation.", count,
 		    totalPixels);
-    #endif
+#endif
 	    count = totalPixels;
 	}
-	
+
 	last = ((double) count)/((double)totalPixels);
     }
 
@@ -6105,15 +6159,18 @@ GetYView(interp, textPtr, report)
 	Tcl_SetObjResult(interp, listObj);
 	return;
     }
+
     if (FP_EQUAL_SCALE(first, dInfoPtr->yScrollFirst, totalPixels) &&
 	FP_EQUAL_SCALE(last,  dInfoPtr->yScrollLast,  totalPixels)) {
 	return;
     }
+
     dInfoPtr->yScrollFirst = first;
     dInfoPtr->yScrollLast = last;
     if (textPtr->yScrollCmd != NULL) {
 	char buf1[TCL_DOUBLE_SPACE+1];
 	char buf2[TCL_DOUBLE_SPACE+1];
+
 	buf1[0] = ' ';
 	buf2[0] = ' ';
 	Tcl_PrintDouble(NULL, first, buf1+1);
@@ -6121,7 +6178,7 @@ GetYView(interp, textPtr, report)
 	code = Tcl_VarEval(interp, textPtr->yScrollCmd, buf1, buf2, NULL);
 	if (code != TCL_OK) {
 	    Tcl_AddErrorInfo(interp,
-		    "\n    (vertical scrolling command executed by text)");
+		    "\n	   (vertical scrolling command executed by text)");
 	    Tcl_BackgroundError(interp);
 	}
     }
@@ -6132,16 +6189,15 @@ GetYView(interp, textPtr, report)
  *
  * AsyncUpdateYScrollbar --
  *
- *	This procedure is called to update the vertical scrollbar
- *	asychronously as the pixel height calculations progress for
- *	lines in the widget.
+ *	This function 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.
+ *	See 'GetYView'. In particular the scrollbar position and size may be
+ *	changed.
  *
  *----------------------------------------------------------------------
  */
@@ -6151,13 +6207,13 @@ AsyncUpdateYScrollbar(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);
     }
@@ -6168,14 +6224,13 @@ AsyncUpdateYScrollbar(clientData)
  *
  * FindDLine --
  *
- *	This procedure is called to find the DLine corresponding to a
- *	given text index.
+ *	This function is called to find the DLine corresponding to a given
+ *	text index.
  *
  * Results:
- *	The return value is a pointer to the first DLine found in the
- *	list headed by dlPtr that displays information at or after the
- *	specified position.  If there is no such line in the list then
- *	NULL is returned.
+ *	The return value is a pointer to the first DLine found in the list
+ *	headed by dlPtr that displays information at or after the specified
+ *	position. If there is no such line in the list then NULL is returned.
  *
  * Side effects:
  *	None.
@@ -6185,8 +6240,8 @@ AsyncUpdateYScrollbar(clientData)
 
 static DLine *
 FindDLine(dlPtr, indexPtr)
-    register DLine *dlPtr;	/* Pointer to first in list of DLines
-				 * to search. */
+    register DLine *dlPtr;	/* Pointer to first in list of DLines to
+				 * search. */
     CONST TkTextIndex *indexPtr;/* Index of desired character. */
 {
     TkTextLine *linePtr;
@@ -6199,6 +6254,7 @@ FindDLine(dlPtr, indexPtr)
 	/*
 	 * The first display line is already past the desired line.
 	 */
+
 	return dlPtr;
     }
 
@@ -6214,11 +6270,12 @@ FindDLine(dlPtr, indexPtr)
 		return NULL;
 	    }
 	}
+
 	/*
-	 * VMD: some concern here as to whether this logic,
-	 * or the caller's logic will work well with 
-	 * partial peer widgets.
+	 * VMD: some concern here as to whether this logic, or the caller's
+	 * logic will work well with partial peer widgets.
 	 */
+
 	linePtr = TkBTreeNextLine(NULL, linePtr);
 	if (linePtr == NULL) {
 	    Tcl_Panic("FindDLine reached end of text");
@@ -6232,7 +6289,7 @@ FindDLine(dlPtr, indexPtr)
      * Now get to the right position within the text line.
      */
 
-    while (indexPtr->byteIndex >= (dlPtr->index.byteIndex + dlPtr->byteCount)) {
+    while (indexPtr->byteIndex >= (dlPtr->index.byteIndex+dlPtr->byteCount)) {
 	dlPtr = dlPtr->nextPtr;
 	if ((dlPtr == NULL) || (dlPtr->index.linePtr != indexPtr->linePtr)) {
 	    break;
@@ -6246,12 +6303,12 @@ FindDLine(dlPtr, indexPtr)
  *
  * TkTextPixelIndex --
  *
- *	Given an (x,y) coordinate on the screen, find the location of
- *	the character closest to that location.
+ *	Given an (x,y) coordinate on the screen, find the location of the
+ *	character closest to that location.
  *
  * Results:
- *	The index at *indexPtr is modified to refer to the character
- *	on the display that is closest to (x,y).
+ *	The index at *indexPtr is modified to refer to the character on the
+ *	display that is closest to (x,y).
  *
  * Side effects:
  *	None.
@@ -6264,21 +6321,20 @@ TkTextPixelIndex(textPtr, x, y, indexPtr, nearest)
     TkText *textPtr;		/* Widget record for text widget. */
     int x, y;			/* Pixel coordinates of point in widget's
 				 * window. */
-    TkTextIndex *indexPtr;	/* This index gets filled in with the
-				 * index of the character nearest to (x,y). */
-    int *nearest;               /* If non-NULL then gets set to 0 if
-                                 * (x,y) is actually over the returned 
-                                 * index, and 1 if it is just nearby
-                                 * (e.g. if x,y is on the border of the
-                                 * widget). */
+    TkTextIndex *indexPtr;	/* This index gets filled in with the index of
+				 * the character nearest to (x,y). */
+    int *nearest;		/* If non-NULL then gets set to 0 if (x,y) is
+				 * actually over the returned index, and 1 if
+				 * it is just nearby (e.g. if x,y is on the
+				 * border of the widget). */
 {
     TextDInfo *dInfoPtr = textPtr->dInfoPtr;
     register DLine *dlPtr, *validDlPtr;
     int nearby = 0;
 
     /*
-     * Make sure that all of the layout information about what's
-     * displayed where on the screen is up-to-date.
+     * Make sure that all of the layout information about what's displayed
+     * where on the screen is up-to-date.
      */
 
     if (dInfoPtr->flags & DINFO_OUT_OF_DATE) {
@@ -6286,9 +6342,9 @@ TkTextPixelIndex(textPtr, x, y, indexPtr, nearest)
     }
 
     /*
-     * If the coordinates are above the top of the window, then adjust
-     * them to refer to the upper-right corner of the window.  If they're
-     * off to one side or the other, then adjust to the closest side.
+     * If the coordinates are above the top of the window, then adjust them to
+     * refer to the upper-right corner of the window. If they're off to one
+     * side or the other, then adjust to the closest side.
      */
 
     if (y < dInfoPtr->y) {
@@ -6304,7 +6360,7 @@ TkTextPixelIndex(textPtr, x, y, indexPtr, nearest)
 	x = dInfoPtr->x;
 	nearby = 1;
     }
-    
+
     /*
      * Find the display line containing the desired y-coordinate.
      */
@@ -6316,14 +6372,14 @@ TkTextPixelIndex(textPtr, x, y, indexPtr, nearest)
 	*indexPtr = textPtr->topIndex;
 	return;
     } else {
-	for (dlPtr = validDlPtr = dInfoPtr->dLinePtr; 
+	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.
+		 * Y-coordinate is off the bottom of the displayed text. Use
+		 * the last character on the last line.
 		 */
 
 		x = dInfoPtr->maxX - 1;
@@ -6333,7 +6389,7 @@ TkTextPixelIndex(textPtr, x, y, indexPtr, nearest)
 	}
 	if (dlPtr->chunkPtr == NULL) dlPtr = validDlPtr;
     }
-        
+
     if (nearest != NULL) {
 	*nearest = nearby;
     }
@@ -6346,14 +6402,14 @@ TkTextPixelIndex(textPtr, x, y, indexPtr, nearest)
  *
  * 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. 
+ *	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.
+ *	The index at *indexPtr is modified to refer to the character on the
+ *	display line that is closest to x.
  *
  * Side effects:
  *	None.
@@ -6364,21 +6420,21 @@ TkTextPixelIndex(textPtr, x, y, indexPtr, nearest)
 static void
 DlineIndexOfX(textPtr, dlPtr, x, indexPtr)
     TkText *textPtr;		/* Widget record for text widget. */
-    DLine *dlPtr;		/* Display information for this
-                 		 * display line. */
+    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. */
+    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
-     * the desired x-coordinate.  Before doing this, translate the
-     * x-coordinate from the coordinate system of the window to the
-     * coordinate system of the line (to take account of x-scrolling).
+     * Scan through the line's chunks to find the one that contains the
+     * desired x-coordinate. Before doing this, translate the x-coordinate
+     * from the coordinate system of the window to the coordinate system of
+     * the line (to take account of x-scrolling).
      */
 
     *indexPtr = dlPtr->index;
@@ -6386,23 +6442,27 @@ DlineIndexOfX(textPtr, dlPtr, x, indexPtr)
     chunkPtr = dlPtr->chunkPtr;
 
     if (chunkPtr == NULL || x == 0) {
-	/* 
-	 * This may occur if everything is elided, or if we're simply
-	 * already at the beginning of the line.
+	/*
+	 * This may occur if everything is elided, or if we're simply already
+	 * at the beginning of the line.
 	 */
+
 	return;
     }
 
     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.
+	/*
+	 * 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 */
+
+	if (TkTextIndexForwBytes(NULL,indexPtr,chunkPtr->numBytes,indexPtr)) {
+	    /*
+	     * We've reached the end of the text.
+	     */
+
 	    return;
 	}
 	if (chunkPtr->nextPtr == NULL) {
@@ -6413,10 +6473,10 @@ DlineIndexOfX(textPtr, dlPtr, x, indexPtr)
     }
 
     /*
-     * If the chunk has more than one byte in it, ask it which
-     * 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 the chunk has more than one byte in it, ask it which 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) {
@@ -6430,10 +6490,10 @@ DlineIndexOfX(textPtr, dlPtr, x, 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.
+ *	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.
@@ -6447,14 +6507,14 @@ DlineIndexOfX(textPtr, dlPtr, x, indexPtr)
 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. */
+    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 
+    DlineIndexOfX(textPtr, dlPtr, x + textPtr->dInfoPtr->x
 		- textPtr->dInfoPtr->curXPixelOffset, indexPtr);
     FreeDLines(textPtr, dlPtr, NULL, DLINE_FREE_TEMP);
 }
@@ -6464,16 +6524,15 @@ TkTextIndexOfX(textPtr, x, indexPtr)
  *
  * 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.
+ *	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.
  *
- *	This is effectively the opposite of DlineIndexOfX. 
- *	
- *	NB. The 'byteIndex' is relative to the display line, NOT the
- *	logical line.
+ *	NB. The 'byteIndex' is relative to the display line, NOT the logical
+ *	line.
  *
  * Results:
  *	The x coordinate.
@@ -6487,25 +6546,26 @@ TkTextIndexOfX(textPtr, x, indexPtr)
 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. */
+    DLine *dlPtr;		/* Display information for this display
+				 * line. */
+    int byteIndex;		/* The byte index for which we want the
+				 * coordinate. */
 {
     register TkTextDispChunk *chunkPtr = dlPtr->chunkPtr;
     int x;
-    
+
     if (byteIndex == 0 || chunkPtr == NULL) return 0;
 
     /*
-     * Scan through the line's chunks to find the one that contains
-     * the desired byte index.
+     * Scan through the line's chunks to find the one that contains the
+     * desired byte index.
      */
 
     chunkPtr = dlPtr->chunkPtr;
     while (byteIndex > 0) {
 	if (byteIndex < chunkPtr->numBytes) {
 	    int y, width, height;
+
 	    (*chunkPtr->bboxProc)(textPtr, chunkPtr, byteIndex,
 		    dlPtr->y + dlPtr->spaceAbove,
 		    dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow,
@@ -6521,7 +6581,7 @@ DlineXOfIndex(textPtr, dlPtr, byteIndex)
 	}
 	chunkPtr = chunkPtr->nextPtr;
     }
-    
+
     return x;
 }
 
@@ -6530,15 +6590,14 @@ DlineXOfIndex(textPtr, dlPtr, byteIndex)
  *
  * TkTextCharBbox --
  *
- *	Given an index, find the bounding box of the screen area
- *	occupied by that character.
+ *	Given an index, find the bounding box of the screen area occupied by
+ *	that character.
  *
  * Results:
- *	Zero is returned if the character is on the screen.  -1
- *	means the character isn't on the screen.  If the return value
- *	is 0, then the bounding box of the part of the character that's
- *	visible on the screen is returned to *xPtr, *yPtr, *widthPtr,
- *	and *heightPtr.
+ *	Zero is returned if the character is on the screen. -1 means the
+ *	character isn't on the screen. If the return value is 0, then the
+ *	bounding box of the part of the character that's visible on the screen
+ *	is returned to *xPtr, *yPtr, *widthPtr, and *heightPtr.
  *
  * Side effects:
  *	None.
@@ -6549,16 +6608,15 @@ DlineXOfIndex(textPtr, dlPtr, byteIndex)
 int
 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. */
+    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 */
+    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;
@@ -6583,8 +6641,7 @@ TkTextCharBbox(textPtr, indexPtr, xPtr, yPtr, widthPtr, heightPtr, charWidthPtr)
     }
 
     /*
-     * Find the chunk within the line that contains the desired
-     * index.
+     * Find the chunk within the line that contains the desired index.
      */
 
     byteIndex = indexPtr->byteIndex - dlPtr->index.byteIndex;
@@ -6599,23 +6656,22 @@ TkTextCharBbox(textPtr, indexPtr, xPtr, yPtr, widthPtr, heightPtr, charWidthPtr)
     }
 
     /*
-     * Call a chunk-specific procedure to find the horizontal range of
-     * the character within the chunk, then fill in the vertical range.
-     * The x-coordinate returned by bboxProc is a coordinate within a
-     * line, not a coordinate on the screen.  Translate it to reflect
-     * horizontal scrolling.
+     * Call a chunk-specific function to find the horizontal range of the
+     * character within the chunk, then fill in the vertical range. The
+     * x-coordinate returned by bboxProc is a coordinate within a line, not a
+     * coordinate on the screen. Translate it to reflect horizontal scrolling.
      */
 
-    (*chunkPtr->bboxProc)(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,
 	    heightPtr);
     *xPtr = *xPtr + dInfoPtr->x - dInfoPtr->curXPixelOffset;
-    if ((byteIndex == (chunkPtr->numBytes - 1)) && (chunkPtr->nextPtr == NULL)) {
+    if ((byteIndex == chunkPtr->numBytes-1) && (chunkPtr->nextPtr == NULL)) {
 	/*
-	 * Last character in display line.  Give it all the space up to
-	 * the line.
+	 * Last character in display line. Give it all the space up to the
+	 * line.
 	 */
 
 	if (charWidthPtr != NULL) {
@@ -6653,14 +6709,14 @@ TkTextCharBbox(textPtr, indexPtr, xPtr, yPtr, widthPtr, heightPtr, charWidthPtr)
  *
  * TkTextDLineInfo --
  *
- *	Given an index, return information about the display line
- *	containing that character.
+ *	Given an index, return information about the display line containing
+ *	that character.
  *
  * Results:
- *	Zero is returned if the character is on the screen.  -1
- *	means the character isn't on the screen.  If the return value
- *	is 0, then information is returned in the variables pointed
- *	to by xPtr, yPtr, widthPtr, heightPtr, and basePtr.
+ *	Zero is returned if the character is on the screen. -1 means the
+ *	character isn't on the screen. If the return value is 0, then
+ *	information is returned in the variables pointed to by xPtr, yPtr,
+ *	widthPtr, heightPtr, and basePtr.
  *
  * Side effects:
  *	None.
@@ -6671,8 +6727,8 @@ TkTextCharBbox(textPtr, indexPtr, xPtr, yPtr, widthPtr, heightPtr, charWidthPtr)
 int
 TkTextDLineInfo(textPtr, indexPtr, xPtr, yPtr, widthPtr, heightPtr, basePtr)
     TkText *textPtr;		/* Widget record for text widget. */
-    CONST TkTextIndex *indexPtr;/* Index of character whose bounding
-				 * box is desired. */
+    CONST TkTextIndex *indexPtr;/* Index of character whose bounding box is
+				 * desired. */
     int *xPtr, *yPtr;		/* Filled with line's upper-left
 				 * coordinate. */
     int *widthPtr, *heightPtr;	/* Filled in with line's dimensions. */
@@ -6716,26 +6772,26 @@ TkTextDLineInfo(textPtr, indexPtr, xPtr, yPtr, widthPtr, heightPtr, basePtr)
 /*
  * Get bounding-box information about an elided chunk
  */
+
 static void
 ElideBboxProc(textPtr, chunkPtr, index, y, lineHeight, baseline, xPtr, yPtr,
 	widthPtr, heightPtr)
     TkText *textPtr;
-    TkTextDispChunk *chunkPtr;		/* Chunk containing desired char. */
-    int index;				/* Index of desired character within
-					 * the chunk. */
-    int y;				/* Topmost pixel in area allocated
-					 * for this line. */
-    int lineHeight;			/* Height of line, in pixels. */
-    int baseline;			/* Location of line's baseline, in
-					 * pixels measured down from y. */
-    int *xPtr, *yPtr;			/* Gets filled in with coords of
-					 * character's upper-left pixel. 
-					 * X-coord is in same coordinate
-					 * system as chunkPtr->x. */
-    int *widthPtr;			/* Gets filled in with width of
-					 * character, in pixels. */
-    int *heightPtr;			/* Gets filled in with height of
-					 * character, in pixels. */
+    TkTextDispChunk *chunkPtr;	/* Chunk containing desired char. */
+    int index;			/* Index of desired character within the
+				 * chunk. */
+    int y;			/* Topmost pixel in area allocated for this
+				 * line. */
+    int lineHeight;		/* Height of line, in pixels. */
+    int baseline;		/* Location of line's baseline, in pixels
+				 * measured down from y. */
+    int *xPtr, *yPtr;		/* Gets filled in with coords of character's
+				 * upper-left pixel. X-coord is in same
+				 * coordinate system as chunkPtr->x. */
+    int *widthPtr;		/* Gets filled in with width of character, in
+				 * pixels. */
+    int *heightPtr;		/* Gets filled in with height of character, in
+				 * pixels. */
 {
     *xPtr = chunkPtr->x;
     *yPtr = y;
@@ -6745,11 +6801,12 @@ ElideBboxProc(textPtr, chunkPtr, index, y, lineHeight, baseline, xPtr, yPtr,
 /*
  * Measure an elided chunk
  */
+
 static int
 ElideMeasureProc(chunkPtr, x)
-    TkTextDispChunk *chunkPtr;		/* Chunk containing desired coord. */
-    int x;				/* X-coordinate, in same coordinate
-					 * system as chunkPtr->x. */
+    TkTextDispChunk *chunkPtr;	/* Chunk containing desired coord. */
+    int x;			/* X-coordinate, in same coordinate system as
+				 * chunkPtr->x. */
 {
     return 0 /*chunkPtr->numBytes - 1*/;
 }
@@ -6759,20 +6816,18 @@ ElideMeasureProc(chunkPtr, x)
  *
  * TkTextCharLayoutProc --
  *
- *	This procedure is the "layoutProc" for character segments.
+ *	This function is the "layoutProc" for character segments.
  *
  * Results:
- *	If there is something to display for the chunk then a
- *	non-zero value is returned and the fields of chunkPtr
- *	will be filled in (see the declaration of TkTextDispChunk
- *	in tkText.h for details).  If zero is returned it means
- *	that no characters from this chunk fit in the window.
- *	If -1 is returned it means that this segment just doesn't
- *	need to be displayed (never happens for text).
+ *	If there is something to display for the chunk then a non-zero value
+ *	is returned and the fields of chunkPtr will be filled in (see the
+ *	declaration of TkTextDispChunk in tkText.h for details). If zero is
+ *	returned it means that no characters from this chunk fit in the
+ *	window. If -1 is returned it means that this segment just doesn't need
+ *	to be displayed (never happens for text).
  *
  * Side effects:
- *	Memory is allocated to hold additional information about
- *	the chunk.
+ *	Memory is allocated to hold additional information about the chunk.
  *
  *--------------------------------------------------------------
  */
@@ -6788,17 +6843,17 @@ TkTextCharLayoutProc(textPtr, indexPtr, segPtr, byteOffset, maxX, maxBytes,
 				 * character to consider. */
     int maxX;			/* Chunk must not occupy pixels at this
 				 * position or higher. */
-    int maxBytes;		/* Chunk must not include more than this
-				 * many characters. */
+    int maxBytes;		/* Chunk must not include more than this 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
-				 * been set by the caller. */
+				/* Structure to fill in with information about
+				 * this chunk. The x field has already been
+				 * set by the caller. */
 {
     Tk_Font tkfont;
     int nextX, bytesThatFit, count;
@@ -6809,33 +6864,33 @@ TkTextCharLayoutProc(textPtr, indexPtr, segPtr, byteOffset, maxX, maxBytes,
 
     /*
      * Figure out how many characters will fit in the space we've got.
-     * Include the next character, even though it won't fit completely,
-     * if any of the following is true:
-     *   (a) the chunk contains no characters and the display line contains
-     *	     no characters yet (i.e. the line isn't wide enough to hold
-     *	     even a single character).
-     *   (b) at least one pixel of the character is visible, we haven't
-     *	     already exceeded the character limit, and the next character
-     *	     is a white space character.
+     * Include the next character, even though it won't fit completely, if any
+     * of the following is true:
+     *	 (a) the chunk contains no characters and the display line contains no
+     *	     characters yet (i.e. the line isn't wide enough to hold even a
+     *	     single character).
+     *	 (b) at least one pixel of the character is visible, we haven't
+     *	     already exceeded the character limit, and the next character is a
+     *	     white space character.
      */
 
     p = segPtr->body.chars + byteOffset;
     tkfont = chunkPtr->stylePtr->sValuePtr->tkfont;
-    bytesThatFit = MeasureChars(tkfont, p, maxBytes, chunkPtr->x, maxX,
-				&nextX);
+    bytesThatFit =
+	    MeasureChars(tkfont, p, maxBytes, chunkPtr->x, maxX, &nextX);
     if (bytesThatFit < maxBytes) {
 	if ((bytesThatFit == 0) && noCharsYet) {
 	    Tcl_UniChar ch;
-	    
+
 	    bytesThatFit = MeasureChars(tkfont, p, Tcl_UtfToUniChar(p, &ch),
 		    chunkPtr->x, -1, &nextX);
 	}
 	if ((nextX < maxX) && ((p[bytesThatFit] == ' ')
 		|| (p[bytesThatFit] == '\t'))) {
 	    /*
-	     * Space characters are funny, in that they are considered
-	     * to fit if there is at least one pixel of space left on the
-	     * line.  Just give the space character whatever space is left.
+	     * Space characters are funny, in that they are considered to fit
+	     * if there is at least one pixel of space left on the line. Just
+	     * give the space character whatever space is left.
 	     */
 
 	    nextX = maxX;
@@ -6853,13 +6908,13 @@ TkTextCharLayoutProc(textPtr, indexPtr, segPtr, byteOffset, maxX, maxBytes,
 	    return 0;
 	}
     }
-	
+
     Tk_GetFontMetrics(tkfont, &fm);
 
     /*
-     * Fill in the chunk structure and allocate and initialize a
-     * CharInfo structure.  If the last character is a newline
-     * then don't bother to display it.
+     * Fill in the chunk structure and allocate and initialize a CharInfo
+     * structure. If the last character is a newline then don't bother to
+     * display it.
      */
 
     chunkPtr->displayProc = CharDisplayProc;
@@ -6882,10 +6937,9 @@ TkTextCharLayoutProc(textPtr, indexPtr, segPtr, byteOffset, maxX, maxBytes,
     }
 
     /*
-     * Compute a break location.  If we're in word wrap mode, a
-     * break can occur after any space character, or at the end of
-     * the chunk if the next segment (ignoring those with zero size)
-     * is not a character segment.
+     * Compute a break location. If we're in word wrap mode, a break can occur
+     * after any space character, or at the end of the chunk if the next
+     * segment (ignoring those with zero size) is not a character segment.
      */
 
     if (wrapMode != TEXT_WRAPMODE_WORD) {
@@ -6918,8 +6972,8 @@ TkTextCharLayoutProc(textPtr, indexPtr, segPtr, byteOffset, maxX, maxBytes,
  *
  * CharDisplayProc --
  *
- *	This procedure is called to display a character chunk on
- *	the screen or in an off-screen pixmap.
+ *	This function is called to display a character chunk on the screen or
+ *	in an off-screen pixmap.
  *
  * Results:
  *	None.
@@ -6933,20 +6987,18 @@ TkTextCharLayoutProc(textPtr, indexPtr, segPtr, byteOffset, maxX, maxBytes,
 static void
 CharDisplayProc(textPtr, chunkPtr, x, y, height, baseline, display, dst, screenY)
     TkText *textPtr;
-    TkTextDispChunk *chunkPtr;		/* Chunk that is to be drawn. */
-    int x;				/* X-position in dst at which to
-					 * draw this chunk (may differ from
-					 * the x-position in the chunk because
-					 * of scrolling). */
-    int y;				/* Y-position at which to draw this
-					 * chunk in dst. */
-    int height;				/* Total height of line. */
-    int baseline;			/* Offset of baseline from y. */
-    Display *display;			/* Display to use for drawing. */
-    Drawable dst;			/* Pixmap or window in which to draw
-					 * chunk. */
-    int screenY;			/* Y-coordinate in text window that
-					 * corresponds to y. */
+    TkTextDispChunk *chunkPtr;	/* Chunk that is to be drawn. */
+    int x;			/* X-position in dst at which to draw this
+				 * chunk (may differ from the x-position in
+				 * the chunk because of scrolling). */
+    int y;			/* Y-position at which to draw this chunk in
+				 * dst. */
+    int height;			/* Total height of line. */
+    int baseline;		/* Offset of baseline from y. */
+    Display *display;		/* Display to use for drawing. */
+    Drawable dst;		/* Pixmap or window in which to draw chunk. */
+    int screenY;		/* Y-coordinate in text window that
+				 * corresponds to y. */
 {
     CharInfo *ciPtr = (CharInfo *) chunkPtr->clientData;
     TextStyle *stylePtr;
@@ -6965,11 +7017,11 @@ CharDisplayProc(textPtr, chunkPtr, x, y, height, baseline, display, dst, screenY
     sValuePtr = stylePtr->sValuePtr;
 
     /*
-     * If the text sticks out way to the left of the window, skip
-     * over the characters that aren't in the visible part of the
-     * window.  This is essential if x is very negative (such as
-     * less than 32K);  otherwise overflow problems will occur
-     * in servers that use 16-bit arithmetic, like X.
+     * If the text sticks out way to the left of the window, skip over the
+     * characters that aren't in the visible part of the window. This is
+     * essential if x is very negative (such as less than 32K); otherwise
+     * overflow problems will occur in servers that use 16-bit arithmetic,
+     * like X.
      */
 
     offsetX = x;
@@ -6983,8 +7035,8 @@ CharDisplayProc(textPtr, 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;
 
@@ -7001,7 +7053,7 @@ CharDisplayProc(textPtr, chunkPtr, x, y, height, baseline, display, dst, screenY
 	}
 	if (sValuePtr->overstrike) {
 	    Tk_FontMetrics fm;
-	    
+
 	    Tk_GetFontMetrics(sValuePtr->tkfont, &fm);
 	    Tk_UnderlineChars(display, dst, stylePtr->fgGC, sValuePtr->tkfont,
 		    ciPtr->chars + offsetBytes, offsetX,
@@ -7017,9 +7069,9 @@ CharDisplayProc(textPtr, chunkPtr, x, y, height, baseline, display, dst, screenY
  *
  * CharUndisplayProc --
  *
- *	This procedure is called when a character chunk is no
- *	longer going to be displayed.  It frees up resources
- *	that were allocated to display the chunk.
+ *	This function is called when a character chunk is no longer going to
+ *	be displayed. It frees up resources that were allocated to display the
+ *	chunk.
  *
  * Results:
  *	None.
@@ -7032,9 +7084,8 @@ CharDisplayProc(textPtr, chunkPtr, x, y, height, baseline, display, dst, screenY
 
 static void
 CharUndisplayProc(textPtr, chunkPtr)
-    TkText *textPtr;			/* Overall information about text
-					 * widget. */
-    TkTextDispChunk *chunkPtr;		/* Chunk that is about to be freed. */
+    TkText *textPtr;		/* Overall information about text widget. */
+    TkTextDispChunk *chunkPtr;	/* Chunk that is about to be freed. */
 {
     CharInfo *ciPtr = (CharInfo *) chunkPtr->clientData;
 
@@ -7046,12 +7097,12 @@ CharUndisplayProc(textPtr, chunkPtr)
  *
  * CharMeasureProc --
  *
- *	This procedure is called to determine which character in
- *	a character chunk lies over a given x-coordinate.
+ *	This function is called to determine which character in a character
+ *	chunk lies over a given x-coordinate.
  *
  * Results:
- *	The return value is the index *within the chunk* of the
- *	character that covers the position given by "x".
+ *	The return value is the index *within the chunk* of the character that
+ *	covers the position given by "x".
  *
  * Side effects:
  *	None.
@@ -7061,16 +7112,15 @@ CharUndisplayProc(textPtr, chunkPtr)
 
 static int
 CharMeasureProc(chunkPtr, x)
-    TkTextDispChunk *chunkPtr;		/* Chunk containing desired coord. */
-    int x;				/* X-coordinate, in same coordinate
-					 * system as chunkPtr->x. */
+    TkTextDispChunk *chunkPtr;	/* Chunk containing desired coord. */
+    int x;			/* X-coordinate, in same coordinate system as
+				 * chunkPtr->x. */
 {
     CharInfo *ciPtr = (CharInfo *) chunkPtr->clientData;
     int endX;
 
     return MeasureChars(chunkPtr->stylePtr->sValuePtr->tkfont, ciPtr->chars,
-	    chunkPtr->numBytes - 1, chunkPtr->x, x, &endX);
-						/* CHAR OFFSET */
+	    chunkPtr->numBytes - 1, chunkPtr->x, x, &endX); /* CHAR OFFSET */
 }
 
 /*
@@ -7078,17 +7128,16 @@ CharMeasureProc(chunkPtr, x)
  *
  * CharBboxProc --
  *
- *	This procedure is called to compute the bounding box of
- *	the area occupied by a single character.
+ *	This function is called to compute the bounding box of the area
+ *	occupied by a single character.
  *
  * Results:
- *	There is no return value.  *xPtr and *yPtr are filled in
- *	with the coordinates of the upper left corner of the
- *	character, and *widthPtr and *heightPtr are filled in with
- *	the dimensions of the character in pixels.  Note:  not all
- *	of the returned bbox is necessarily visible on the screen
- *	(the rightmost part might be off-screen to the right,
- *	and the bottommost part might be off-screen to the bottom).
+ *	There is no return value. *xPtr and *yPtr are filled in with the
+ *	coordinates of the upper left corner of the character, and *widthPtr
+ *	and *heightPtr are filled in with the dimensions of the character in
+ *	pixels. Note: not all of the returned bbox is necessarily visible on
+ *	the screen (the rightmost part might be off-screen to the right, and
+ *	the bottommost part might be off-screen to the bottom).
  *
  * Side effects:
  *	None.
@@ -7100,22 +7149,21 @@ static void
 CharBboxProc(textPtr, chunkPtr, byteIndex, y, lineHeight, baseline, xPtr, yPtr,
 	widthPtr, heightPtr)
     TkText *textPtr;
-    TkTextDispChunk *chunkPtr;		/* Chunk containing desired char. */
-    int byteIndex;			/* Byte offset of desired character
-					 * within the chunk. */
-    int y;				/* Topmost pixel in area allocated
-					 * for this line. */
-    int lineHeight;			/* Height of line, in pixels. */
-    int baseline;			/* Location of line's baseline, in
-					 * pixels measured down from y. */
-    int *xPtr, *yPtr;			/* Gets filled in with coords of
-					 * character's upper-left pixel. 
-					 * X-coord is in same coordinate
-					 * system as chunkPtr->x. */
-    int *widthPtr;			/* Gets filled in with width of
-					 * character, in pixels. */
-    int *heightPtr;			/* Gets filled in with height of
-					 * character, in pixels. */
+    TkTextDispChunk *chunkPtr;	/* Chunk containing desired char. */
+    int byteIndex;		/* Byte offset of desired character within the
+				 * chunk. */
+    int y;			/* Topmost pixel in area allocated for this
+				 * line. */
+    int lineHeight;		/* Height of line, in pixels. */
+    int baseline;		/* Location of line's baseline, in pixels
+				 * measured down from y. */
+    int *xPtr, *yPtr;		/* Gets filled in with coords of character's
+				 * upper-left pixel. X-coord is in same
+				 * coordinate system as chunkPtr->x. */
+    int *widthPtr;		/* Gets filled in with width of character, in
+				 * pixels. */
+    int *heightPtr;		/* Gets filled in with height of character, in
+				 * pixels. */
 {
     CharInfo *ciPtr = (CharInfo *) chunkPtr->clientData;
     int maxX;
@@ -7126,22 +7174,22 @@ CharBboxProc(textPtr, chunkPtr, byteIndex, y, lineHeight, baseline, xPtr, yPtr,
 
     if (byteIndex == ciPtr->numBytes) {
 	/*
-	 * This situation only happens if the last character in a line
-	 * is a space character, in which case it absorbs all of the
-	 * extra space in the line (see TkTextCharLayoutProc).
+	 * This situation only happens if the last character in a line is a
+	 * space character, in which case it absorbs all of the extra space in
+	 * the line (see TkTextCharLayoutProc).
 	 */
 
 	*widthPtr = maxX - *xPtr;
     } else if ((ciPtr->chars[byteIndex] == '\t')
 	    && (byteIndex == ciPtr->numBytes - 1)) {
 	/*
-	 * The desired character is a tab character that terminates a
-	 * chunk;  give it all the space left in the chunk.
+	 * The desired character is a tab character that terminates a chunk;
+	 * give it all the space left in the chunk.
 	 */
 
 	*widthPtr = maxX - *xPtr;
     } else {
-	MeasureChars(chunkPtr->stylePtr->sValuePtr->tkfont, 
+	MeasureChars(chunkPtr->stylePtr->sValuePtr->tkfont,
 		ciPtr->chars + byteIndex, 1, *xPtr, -1, widthPtr);
 	if (*widthPtr > maxX) {
 	    *widthPtr = maxX - *xPtr;
@@ -7158,35 +7206,32 @@ CharBboxProc(textPtr, chunkPtr, byteIndex, y, lineHeight, baseline, xPtr, yPtr,
  *
  * AdjustForTab --
  *
- *	This procedure is called to move a series of chunks right
- *	in order to align them with a tab stop.
+ *	This function is called to move a series of chunks right in order to
+ *	align them with a tab stop.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The width of chunkPtr gets adjusted so that it absorbs the
- *	extra space due to the tab.  The x locations in all the chunks
- *	after chunkPtr are adjusted rightward to align with the tab
- *	stop given by tabArrayPtr and index.
+ *	The width of chunkPtr gets adjusted so that it absorbs the extra space
+ *	due to the tab. The x locations in all the chunks after chunkPtr are
+ *	adjusted rightward to align with the tab stop given by tabArrayPtr and
+ *	index.
  *
  *----------------------------------------------------------------------
  */
 
 static void
 AdjustForTab(textPtr, tabArrayPtr, index, chunkPtr)
-    TkText *textPtr;			/* Information about the text widget as
-					 * a whole. */
-    TkTextTabArray *tabArrayPtr;	/* Information about the tab stops
-					 * that apply to this line.  May be
-					 * NULL to indicate default tabbing
-					 * (every 8 chars). */
-    int index;				/* Index of current tab stop. */
-    TkTextDispChunk *chunkPtr;		/* Chunk whose last character is
-					 * the tab;  the following chunks
-					 * contain information to be shifted
-					 * right. */
-
+    TkText *textPtr;		/* Information about the text widget as a
+				 * whole. */
+    TkTextTabArray *tabArrayPtr;/* Information about the tab stops that apply
+				 * to this line. May be NULL to indicate
+				 * default tabbing (every 8 chars). */
+    int index;			/* Index of current tab stop. */
+    TkTextDispChunk *chunkPtr;	/* Chunk whose last character is the tab; the
+				 * following chunks contain information to be
+				 * shifted right. */
 {
     int x, desired, delta, width, decimal, i, gotDigit;
     TkTextDispChunk *chunkPtr2, *decimalChunkPtr;
@@ -7204,8 +7249,8 @@ AdjustForTab(textPtr, tabArrayPtr, index, chunkPtr)
     }
 
     /*
-     * If no tab information has been given, do the usual thing:
-     * round up to the next boundary of 8 average-sized characters.
+     * If no tab information has been given, do the usual thing: round up to
+     * the next boundary of 8 average-sized characters.
      */
 
     x = chunkPtr->nextPtr->x;
@@ -7224,13 +7269,13 @@ AdjustForTab(textPtr, tabArrayPtr, index, chunkPtr)
 	tabX = tabArrayPtr->tabs[index].location;
     } else {
 	/*
-	 * Ran out of tab stops;  compute a tab position by extrapolating
-	 * from the last two tab positions.
+	 * Ran out of tab stops; compute a tab position by extrapolating from
+	 * the last two tab positions.
 	 */
 
-	tabX = (int) (tabArrayPtr->lastTab 
-		      + (index + 1 - tabArrayPtr->numTabs) 
-		      * tabArrayPtr->tabIncrement + 0.5);
+	tabX = (int) (tabArrayPtr->lastTab +
+		(index + 1 - tabArrayPtr->numTabs)*tabArrayPtr->tabIncrement +
+		0.5);
 	alignment = tabArrayPtr->tabs[tabArrayPtr->numTabs-1].alignment;
     }
 
@@ -7241,8 +7286,8 @@ AdjustForTab(textPtr, tabArrayPtr, index, chunkPtr)
 
     if ((alignment == CENTER) || (alignment == RIGHT)) {
 	/*
-	 * Compute the width of all the information in the tab group,
-	 * then use it to pick a desired location.
+	 * Compute the width of all the information in the tab group, then use
+	 * it to pick a desired location.
 	 */
 
 	width = 0;
@@ -7259,9 +7304,9 @@ AdjustForTab(textPtr, tabArrayPtr, index, chunkPtr)
     }
 
     /*
-     * Must be numeric alignment.  Search through the text to be
-     * tabbed, looking for the last , or . before the first character
-     * that isn't a number, comma, period, or sign.
+     * Must be numeric alignment. Search through the text to be tabbed,
+     * looking for the last , or . before the first character that isn't a
+     * number, comma, period, or sign.
      */
 
     decimalChunkPtr = NULL;
@@ -7287,7 +7332,8 @@ AdjustForTab(textPtr, tabArrayPtr, index, chunkPtr)
 	    }
 	}
     }
-    endOfNumber:
+
+  endOfNumber:
     if (decimalChunkPtr != NULL) {
 	int curX;
 
@@ -7298,9 +7344,9 @@ AdjustForTab(textPtr, tabArrayPtr, index, chunkPtr)
 	goto update;
     } else {
 	/*
-	 * There wasn't a decimal point.  Right justify the text.
+	 * There wasn't a decimal point. Right justify the text.
 	 */
-    
+
 	width = 0;
 	for (chunkPtr2 = chunkPtr->nextPtr; chunkPtr2 != NULL;
 		chunkPtr2 = chunkPtr2->nextPtr) {
@@ -7310,13 +7356,12 @@ AdjustForTab(textPtr, tabArrayPtr, index, chunkPtr)
     }
 
     /*
-     * Shift all of the chunks to the right so that the left edge is
-     * at the desired location, then expand the chunk containing the
-     * tab.  Be sure that the tab occupies at least the width of a
-     * space character.
+     * Shift all of the chunks to the right so that the left edge is at the
+     * desired location, then expand the chunk containing the tab. Be sure
+     * that the tab occupies at least the width of a space character.
      */
 
-    update:
+  update:
     delta = desired - x;
     MeasureChars(textPtr->tkfont, " ", 1, 0, -1, &spaceWidth);
     if (delta < spaceWidth) {
@@ -7334,19 +7379,18 @@ AdjustForTab(textPtr, tabArrayPtr, index, chunkPtr)
  *
  * SizeOfTab --
  *
- *	This returns an estimate of the amount of white space that will
- *	be consumed by a tab.
+ *	This returns an estimate of the amount of white space that will be
+ *	consumed by a tab.
  *
  * Results:
- *	The return value is the minimum number of pixels that will
- *	be occupied by the next tab of tabArrayPtr, assuming that
- *	the current position on the line is x and the end of the
- *	line is maxX.  The 'next tab' is determined by a combination
- *	of the current position (x) which it must be equal to or
- *	beyond, and the tab count in indexPtr.
- *	
- *	For numeric tabs, this is a conservative estimate.  The return
- *	value is always >= 0.
+ *	The return value is the minimum number of pixels that will be occupied
+ *	by the next tab of tabArrayPtr, assuming that the current position on
+ *	the line is x and the end of the line is maxX. The 'next tab' is
+ *	determined by a combination of the current position (x) which it must
+ *	be equal to or beyond, and the tab count in indexPtr.
+ *
+ *	For numeric tabs, this is a conservative estimate. The return value is
+ *	always >= 0.
  *
  * Side effects:
  *	None.
@@ -7356,69 +7400,70 @@ AdjustForTab(textPtr, tabArrayPtr, index, chunkPtr)
 
 static int
 SizeOfTab(textPtr, tabArrayPtr, indexPtr, x, maxX)
-    TkText *textPtr;			/* Information about the text widget as
-					 * a whole. */
-    TkTextTabArray *tabArrayPtr;	/* Information about the tab stops
-					 * that apply to this line.  NULL
-					 * means use default tabbing (every
-					 * 8 chars.) */
-    int *indexPtr;			/* Contains index of previous tab 
-                  			 * stop, will be updated to
-                  			 * reflect the number of stops
-                  			 * used. */
-    int x;				/* Current x-location in line. */
-    int maxX;				/* X-location of pixel just past the
-					 * right edge of the line. */
+    TkText *textPtr;		/* Information about the text widget as a
+				 * whole. */
+    TkTextTabArray *tabArrayPtr;/* Information about the tab stops that apply
+				 * to this line. NULL means use default
+				 * tabbing (every 8 chars.) */
+    int *indexPtr;		/* Contains index of previous tab stop, will
+				 * be updated to reflect the number of stops
+				 * used. */
+    int x;			/* Current x-location in line. */
+    int maxX;			/* X-location of pixel just past the right
+				 * edge of the line. */
 {
     int tabX, result, index, spaceWidth;
     TkTextTabAlign alignment;
-    
+
     index = *indexPtr;
 
     if ((tabArrayPtr == NULL) || (tabArrayPtr->numTabs == 0)) {
 	tabX = NextTabStop(textPtr->tkfont, x, 0);
-	/* 
+
+	/*
 	 * We used up one tab stop.
 	 */
+
 	*indexPtr = index+1;
 	return tabX - x;
     }
 
     do {
-	/* 
-	 * We were given the count before this tab, so increment it
-	 * first.
+	/*
+	 * We were given the count before this tab, so increment it first.
 	 */
+
 	index++;
 	if (index < tabArrayPtr->numTabs) {
 	    tabX = tabArrayPtr->tabs[index].location;
 	    alignment = tabArrayPtr->tabs[index].alignment;
 	} else {
 	    /*
-	     * Ran out of tab stops; compute a tab position by
-	     * extrapolating.
+	     * Ran out of tab stops; compute a tab position by extrapolating.
 	     */
-	    tabX = (int) (tabArrayPtr->lastTab 
-			  + (index + 1 - tabArrayPtr->numTabs) 
-			  * tabArrayPtr->tabIncrement + 0.5);
+
+	    tabX = (int) (tabArrayPtr->lastTab
+		    + (index + 1 - tabArrayPtr->numTabs)
+		    * tabArrayPtr->tabIncrement + 0.5);
 	    alignment = tabArrayPtr->tabs[tabArrayPtr->numTabs-1].alignment;
 	}
-	/* 
-	 * If this tab stop is before the current x position, then we
-	 * must obviously continue until we reach the text tab stop.
+
+	/*
+	 * If this tab stop is before the current x position, then we must
+	 * obviously continue until we reach the text tab stop.
 	 */
     } while (tabX < x);
-    
-    /* 
+
+    /*
      * Inform our caller of how many tab stops we've used up.
      */
+
     *indexPtr = index;
-    
+
     if (alignment == CENTER) {
 	/*
-	 * Be very careful in the arithmetic below, because maxX may
-	 * be the largest positive number:  watch out for integer
-	 * overflow.
+	 * Be very careful in the arithmetic below, because maxX may be the
+	 * largest positive number: watch out for integer overflow.
 	 */
 
 	if ((maxX-tabX) < (tabX - x)) {
@@ -7434,10 +7479,9 @@ SizeOfTab(textPtr, tabArrayPtr, indexPtr, x, maxX)
     }
 
     /*
-     * Note: this treats NUMERIC alignment the same as LEFT
-     * alignment, which is somewhat conservative.  However, it's
-     * pretty tricky at this point to figure out exactly where
-     * the damn decimal point will be.
+     * Note: this treats NUMERIC alignment the same as LEFT alignment, which
+     * is somewhat conservative. However, it's pretty tricky at this point to
+     * figure out exactly where the damn decimal point will be.
      */
 
     if (tabX > x) {
@@ -7446,7 +7490,7 @@ SizeOfTab(textPtr, tabArrayPtr, indexPtr, x, maxX)
 	result = 0;
     }
 
-    done:
+  done:
     MeasureChars(textPtr->tkfont, " ", 1, 0, -1, &spaceWidth);
     if (result < spaceWidth) {
 	result = spaceWidth;
@@ -7459,10 +7503,10 @@ SizeOfTab(textPtr, tabArrayPtr, indexPtr, x, maxX)
  *
  * NextTabStop --
  *
- *	Given the current position, determine where the next default
- *	tab stop would be located.  This procedure is called when the
- *	current chunk in the text has no tabs defined and so the default
- *	tab spacing for the font should be used.
+ *	Given the current position, determine where the next default tab stop
+ *	would be located. This function is called when the current chunk in
+ *	the text has no tabs defined and so the default tab spacing for the
+ *	font should be used.
  *
  * Results:
  *	The location in pixels of the next tab stop.
@@ -7475,16 +7519,16 @@ SizeOfTab(textPtr, tabArrayPtr, indexPtr, x, maxX)
 
 static int
 NextTabStop(tkfont, x, tabOrigin)
-    Tk_Font tkfont;		/* Font in which chunk that contains tab
-				 * stop will be drawn. */
-    int x;			/* X-position in pixels where last
-				 * character was drawn.  The next tab stop
-				 * occurs somewhere after this location. */
-    int tabOrigin;		/* The origin for tab stops.  May be
-				 * non-zero if text has been scrolled. */
+    Tk_Font tkfont;		/* Font in which chunk that contains tab stop
+				 * will be drawn. */
+    int x;			/* X-position in pixels where last character
+				 * was drawn. The next tab stop occurs
+				 * somewhere after this location. */
+    int tabOrigin;		/* The origin for tab stops. May be non-zero
+				 * if text has been scrolled. */
 {
     int tabWidth, rem;
-    
+
     tabWidth = Tk_TextWidth(tkfont, "0", 1) * 8;
     if (tabWidth == 0) {
 	tabWidth = 1;
@@ -7504,23 +7548,22 @@ NextTabStop(tkfont, x, tabOrigin)
  *
  *  MeasureChars --
  *
- *	Determine the number of characters from the string that will fit
- *	in the given horizontal span.  The measurement is done under the
- *	assumption that Tk_DrawChars will be used to actually display
- *	the characters.
+ *	Determine the number of characters from the string that will fit in
+ *	the given horizontal span. The measurement is done under the
+ *	assumption that Tk_DrawChars will be used to actually display the
+ *	characters.
  *
- *	If tabs are encountered in the string, they will be expanded
- *	to the next tab stop.
+ *	If tabs are encountered in the string, they will be expanded to the
+ *	next tab stop.
  *
- *	If a newline is encountered in the string, the line will be
- *	broken at that point.
+ *	If a newline is encountered in the string, the line will be broken at
+ *	that point.
  *
  * Results:
- *	The return value is the number of bytes from source
- *	that fit in the span given by startX and maxX.  *nextXPtr
- *	is filled in with the x-coordinate at which the first
- *	character that didn't fit would be drawn, if it were to
- *	be drawn.
+ *	The return value is the number of bytes from source that fit in the
+ *	span given by startX and maxX. *nextXPtr is filled in with the
+ *	x-coordinate at which the first character that didn't fit would be
+ *	drawn, if it were to be drawn.
  *
  * Side effects:
  *	None.
@@ -7531,16 +7574,16 @@ NextTabStop(tkfont, x, tabOrigin)
 static int
 MeasureChars(tkfont, source, maxBytes, startX, maxX, nextXPtr)
     Tk_Font tkfont;		/* Font in which to draw characters. */
-    CONST char *source;		/* Characters to be displayed.  Need not
-				 * be NULL-terminated. */
+    CONST char *source;		/* Characters to be displayed. Need not be
+				 * NULL-terminated. */
     int maxBytes;		/* Maximum # of bytes to consider from
 				 * source. */
-    int startX;			/* X-position at which first character will
-				 * be drawn. */
+    int startX;			/* X-position at which first character will be
+				 * drawn. */
     int maxX;			/* Don't consider any character that would
 				 * cross this x-position. */
-    int *nextXPtr;		/* Return x-position of terminating
-				 * character here. */
+    int *nextXPtr;		/* Return x-position of terminating character
+				 * here. */
 {
     int curX, width, ch;
     CONST char *special, *end, *start;
@@ -7565,13 +7608,13 @@ MeasureChars(tkfont, source, maxBytes, startX, maxX, nextXPtr)
 
 	/*
 	 * Special points at the next special character (or the end of the
-	 * string).  Process characters between start and special.
+	 * string). Process characters between start and special.
 	 */
 
 	if ((maxX >= 0) && (curX >= maxX)) {
 	    break;
 	}
-	start += Tk_MeasureChars(tkfont, start, special - start, 
+	start += Tk_MeasureChars(tkfont, start, special - start,
 				 maxX - curX, 0, &width);
 	curX += width;
 	if (start < special) {
@@ -7599,24 +7642,22 @@ MeasureChars(tkfont, source, maxBytes, startX, maxX, nextXPtr)
  *
  * TextGetScrollInfoObj --
  *
- *	This procedure is invoked to parse "xview" and "yview" scrolling
+ *	This function is invoked to parse "xview" and "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.
+ *	("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
+ *	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.
+ *	pages/pixels/lines to move (may be negative); if TKTEXT_SCROLL_ERROR,
+ *	the interp's result contains an error message.
  *
  * Side effects:
  *	None.
@@ -7626,16 +7667,14 @@ MeasureChars(tkfont, source, maxBytes, startX, maxX, nextXPtr)
 
 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. */
+    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;
     int length;
@@ -7655,9 +7694,9 @@ TextGetScrollInfoObj(interp, textPtr, objc, objv, dblPtr, intPtr)
     } else if (c=='s' && strncmp(arg2, "scroll", (unsigned) length)==0) {
 	CONST char *arg4;
 	size_t argLen;
-	
+
 	if (objc != 5) {
-	    Tcl_WrongNumArgs(interp, 2, objv, 
+	    Tcl_WrongNumArgs(interp, 2, objv,
 	    "scroll number units|pages|pixels");
 	    return TKTEXT_SCROLL_ERROR;
 	}
@@ -7674,7 +7713,7 @@ TextGetScrollInfoObj(interp, textPtr, objc, objv, dblPtr, intPtr)
 	    }
 	    return TKTEXT_SCROLL_PAGES;
 	} else if (c=='p' && strncmp(arg4, "pixels", argLen)==0) {
-	    if (Tk_GetPixelsFromObj(interp, textPtr->tkwin, objv[3], 
+	    if (Tk_GetPixelsFromObj(interp, textPtr->tkwin, objv[3],
 		    intPtr) != TCL_OK) {
 		return TKTEXT_SCROLL_ERROR;
 	    }
@@ -7694,4 +7733,11 @@ TextGetScrollInfoObj(interp, textPtr, objc, objv, dblPtr, intPtr)
 	    "\": must be moveto or scroll", (char *) NULL);
     return TKTEXT_SCROLL_ERROR;
 }
-
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */