Formatting systematization

1 files changed, 379 insertions, 387 deletions

diff --git a/generic/tkTrig.c b/generic/tkTrig.c
index f3561b1..4dbf755 100644
--- a/generic/tkTrig.c
+++ b/generic/tkTrig.c
@@ -1,18 +1,17 @@
-/* 
+/*
  * tkTrig.c --
  *
- *	This file contains a collection of trigonometry utility
- *	routines that are used by Tk and in particular by the
- *	canvas code.  It also has miscellaneous geometry functions
- *	used by canvases.
+ *	This file contains a collection of trigonometry utility routines that
+ *	are used by Tk and in particular by the canvas code. It also has
+ *	miscellaneous geometry functions used by canvases.
  *
  * 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: tkTrig.c,v 1.5 2004/08/19 14:41:52 dkf Exp $
+ * RCS: @(#) $Id: tkTrig.c,v 1.6 2005/08/18 18:32:38 dkf Exp $
  */
 
 #include <stdio.h>
@@ -36,9 +35,8 @@
  *	Compute the distance from a point to a finite line segment.
  *
  * Results:
- *	The return value is the distance from the line segment
- *	whose end-points are *end1Ptr and *end2Ptr to the point
- *	given by *pointPtr.
+ *	The return value is the distance from the line segment whose
+ *	end-points are *end1Ptr and *end2Ptr to the point given by *pointPtr.
  *
  * Side effects:
  *	None.
@@ -55,9 +53,9 @@ TkLineToPoint(end1Ptr, end2Ptr, pointPtr)
     double x, y;
 
     /*
-     * Compute the point on the line that is closest to the
-     * point.  This must be done separately for vertical edges,
-     * horizontal edges, and other edges.
+     * Compute the point on the line that is closest to the point. This must
+     * be done separately for vertical edges, horizontal edges, and other
+     * edges.
      */
 
     if (end1Ptr[0] == end2Ptr[0]) {
@@ -92,10 +90,10 @@ TkLineToPoint(end1Ptr, end2Ptr, pointPtr)
 	double m1, b1, m2, b2;
 
 	/*
-	 * The edge is neither horizontal nor vertical.  Convert the
-	 * edge to a line equation of the form y = m1*x + b1.  Then
-	 * compute a line perpendicular to this edge but passing
-	 * through the point, also in the form y = m2*x + b2.
+	 * The edge is neither horizontal nor vertical. Convert the edge to a
+	 * line equation of the form y = m1*x + b1. Then compute a line
+	 * perpendicular to this edge but passing through the point, also in
+	 * the form y = m2*x + b2.
 	 */
 
 	m1 = (end2Ptr[1] - end1Ptr[1])/(end2Ptr[0] - end1Ptr[0]);
@@ -135,14 +133,14 @@ TkLineToPoint(end1Ptr, end2Ptr, pointPtr)
  *
  * TkLineToArea --
  *
- *	Determine whether a line lies entirely inside, entirely
- *	outside, or overlapping a given rectangular area.
+ *	Determine whether a line lies entirely inside, entirely outside, or
+ *	overlapping a given rectangular area.
  *
  * Results:
- *	-1 is returned if the line given by end1Ptr and end2Ptr
- *	is entirely outside the rectangle given by rectPtr.  0 is
- *	returned if the polygon overlaps the rectangle, and 1 is
- *	returned if the polygon is entirely inside the rectangle.
+ *	-1 is returned if the line given by end1Ptr and end2Ptr is entirely
+ *	outside the rectangle given by rectPtr. 0 is returned if the polygon
+ *	overlaps the rectangle, and 1 is returned if the polygon is entirely
+ *	inside the rectangle.
  *
  * Side effects:
  *	None.
@@ -152,19 +150,19 @@ TkLineToPoint(end1Ptr, end2Ptr, pointPtr)
 
 int
 TkLineToArea(end1Ptr, end2Ptr, rectPtr)
-    double end1Ptr[2];		/* X and y coordinates for one endpoint
-				 * of line. */
-    double end2Ptr[2];		/* X and y coordinates for other endpoint
-				 * of line. */
+    double end1Ptr[2];		/* X and y coordinates for one endpoint of
+				 * line. */
+    double end2Ptr[2];		/* X and y coordinates for other endpoint of
+				 * line. */
     double rectPtr[4];		/* Points to coords for rectangle, in the
-				 * order x1, y1, x2, y2.  X1 must be no
-				 * larger than x2, and y1 no larger than y2. */
+				 * order x1, y1, x2, y2. X1 must be no larger
+				 * than x2, and y1 no larger than y2. */
 {
     int inside1, inside2;
 
     /*
-     * First check the two points individually to see whether they
-     * are inside the rectangle or not.
+     * First check the two points individually to see whether they are inside
+     * the rectangle or not.
      */
 
     inside1 = (end1Ptr[0] >= rectPtr[0]) && (end1Ptr[0] <= rectPtr[2])
@@ -179,17 +177,16 @@ TkLineToArea(end1Ptr, end2Ptr, rectPtr)
     }
 
     /*
-     * Both points are outside the rectangle, but still need to check
-     * for intersections between the line and the rectangle.  Horizontal
-     * and vertical lines are particularly easy, so handle them
-     * separately.
+     * Both points are outside the rectangle, but still need to check for
+     * intersections between the line and the rectangle. Horizontal and
+     * vertical lines are particularly easy, so handle them separately.
      */
 
     if (end1Ptr[0] == end2Ptr[0]) {
 	/*
 	 * Vertical line.
 	 */
-    
+
 	if (((end1Ptr[1] >= rectPtr[1]) ^ (end2Ptr[1] >= rectPtr[1]))
 		&& (end1Ptr[0] >= rectPtr[0])
 		&& (end1Ptr[0] <= rectPtr[2])) {
@@ -199,7 +196,7 @@ TkLineToArea(end1Ptr, end2Ptr, rectPtr)
 	/*
 	 * Horizontal line.
 	 */
-    
+
 	if (((end1Ptr[0] >= rectPtr[0]) ^ (end2Ptr[0] >= rectPtr[0]))
 		&& (end1Ptr[1] >= rectPtr[1])
 		&& (end1Ptr[1] <= rectPtr[3])) {
@@ -207,59 +204,63 @@ TkLineToArea(end1Ptr, end2Ptr, rectPtr)
 	}
     } else {
 	double m, x, y, low, high;
-    
+
 	/*
-	 * Diagonal line.  Compute slope of line and use
-	 * for intersection checks against each of the
-	 * sides of the rectangle: left, right, bottom, top.
+	 * Diagonal line. Compute slope of line and use for intersection
+	 * checks against each of the sides of the rectangle: left, right,
+	 * bottom, top.
 	 */
-    
+
 	m = (end2Ptr[1] - end1Ptr[1])/(end2Ptr[0] - end1Ptr[0]);
 	if (end1Ptr[0] < end2Ptr[0]) {
-	    low = end1Ptr[0];  high = end2Ptr[0];
+	    low = end1Ptr[0];
+	    high = end2Ptr[0];
 	} else {
-	    low = end2Ptr[0]; high = end1Ptr[0];
+	    low = end2Ptr[0];
+	    high = end1Ptr[0];
 	}
-    
+
 	/*
 	 * Left edge.
 	 */
-    
+
 	y = end1Ptr[1] + (rectPtr[0] - end1Ptr[0])*m;
 	if ((rectPtr[0] >= low) && (rectPtr[0] <= high)
 		&& (y >= rectPtr[1]) && (y <= rectPtr[3])) {
 	    return 0;
 	}
-    
+
 	/*
 	 * Right edge.
 	 */
-    
+
 	y += (rectPtr[2] - rectPtr[0])*m;
 	if ((y >= rectPtr[1]) && (y <= rectPtr[3])
 		&& (rectPtr[2] >= low) && (rectPtr[2] <= high)) {
 	    return 0;
 	}
-    
+
 	/*
 	 * Bottom edge.
 	 */
-    
+
 	if (end1Ptr[1] < end2Ptr[1]) {
-	    low = end1Ptr[1];  high = end2Ptr[1];
+	    low = end1Ptr[1];
+	    high = end2Ptr[1];
 	} else {
-	    low = end2Ptr[1]; high = end1Ptr[1];
+	    low = end2Ptr[1];
+	    high = end1Ptr[1];
 	}
 	x = end1Ptr[0] + (rectPtr[1] - end1Ptr[1])/m;
 	if ((x >= rectPtr[0]) && (x <= rectPtr[2])
 		&& (rectPtr[1] >= low) && (rectPtr[1] <= high)) {
 	    return 0;
 	}
-    
+
 	/*
 	 * Top edge.
 	 */
-    
+
 	x += (rectPtr[3] - rectPtr[1])/m;
 	if ((x >= rectPtr[0]) && (x <= rectPtr[2])
 		&& (rectPtr[3] >= low) && (rectPtr[3] <= high)) {
@@ -274,14 +275,13 @@ TkLineToArea(end1Ptr, end2Ptr, rectPtr)
  *
  * TkThickPolyLineToArea --
  *
- *	This procedure is called to determine whether a connected
- *	series of line segments lies entirely inside, entirely
- *	outside, or overlapping a given rectangular area.
+ *	This function is called to determine whether a connected series of
+ *	line segments lies entirely inside, entirely outside, or overlapping a
+ *	given rectangular area.
  *
  * Results:
- *	-1 is returned if the lines are entirely outside the area,
- *	0 if they overlap, and 1 if they are entirely inside the
- *	given area.
+ *	-1 is returned if the lines are entirely outside the area, 0 if they
+ *	overlap, and 1 if they are entirely inside the given area.
  *
  * Side effects:
  *	None.
@@ -292,8 +292,8 @@ TkLineToArea(end1Ptr, end2Ptr, rectPtr)
 	/* ARGSUSED */
 int
 TkThickPolyLineToArea(coordPtr, numPoints, width, capStyle, joinStyle, rectPtr)
-    double *coordPtr;		/* Points to an array of coordinates for
-				 * the polyline:  x0, y0, x1, y1, ... */
+    double *coordPtr;		/* Points to an array of coordinates for the
+				 * polyline: x0, y0, x1, y1, ... */
     int numPoints;		/* Total number of points at *coordPtr. */
     double width;		/* Width of each line segment. */
     int capStyle;		/* How are end-points of polyline drawn?
@@ -304,15 +304,14 @@ TkThickPolyLineToArea(coordPtr, numPoints, width, capStyle, joinStyle, rectPtr)
 {
     double radius, poly[10];
     int count;
-    int changedMiterToBevel;	/* Non-zero means that a mitered corner
-				 * had to be treated as beveled after all
-				 * because the angle was < 11 degrees. */
-    int inside;			/* Tentative guess about what to return,
-				 * based on all points seen so far:  one
-				 * means everything seen so far was
-				 * inside the area;  -1 means everything
-				 * was outside the area.  0 means overlap
-				 * has been found. */ 
+    int changedMiterToBevel;	/* Non-zero means that a mitered corner had to
+				 * be treated as beveled after all because the
+				 * angle was < 11 degrees. */
+    int inside;			/* Tentative guess about what to return, based
+				 * on all points seen so far: one means
+				 * everything seen so far was inside the area;
+				 * -1 means everything was outside the area.
+				 * 0 means overlap has been found. */
 
     radius = width/2.0;
     inside = -1;
@@ -323,19 +322,16 @@ TkThickPolyLineToArea(coordPtr, numPoints, width, capStyle, joinStyle, rectPtr)
     }
 
     /*
-     * Iterate through all of the edges of the line, computing a polygon
-     * for each edge and testing the area against that polygon.  In
-     * addition, there are additional tests to deal with rounded joints
-     * and caps.
+     * Iterate through all of the edges of the line, computing a polygon for
+     * each edge and testing the area against that polygon. In addition, there
+     * are additional tests to deal with rounded joints and caps.
      */
 
     changedMiterToBevel = 0;
     for (count = numPoints; count >= 2; count--, coordPtr += 2) {
-
 	/*
-	 * If rounding is done around the first point of the edge
-	 * then test a circular region around the point with the
-	 * area.
+	 * If rounding is done around the first point of the edge then test a
+	 * circular region around the point with the area.
 	 */
 
 	if (((capStyle == CapRound) && (count == numPoints))
@@ -350,9 +346,9 @@ TkThickPolyLineToArea(coordPtr, numPoints, width, capStyle, joinStyle, rectPtr)
 	}
 
 	/*
-	 * Compute the polygonal shape corresponding to this edge,
-	 * consisting of two points for the first point of the edge
-	 * and two points for the last point of the edge.
+	 * Compute the polygonal shape corresponding to this edge, consisting
+	 * of two points for the first point of the edge and two points for
+	 * the last point of the edge.
 	 */
 
 	if (count == numPoints) {
@@ -367,10 +363,10 @@ TkThickPolyLineToArea(coordPtr, numPoints, width, capStyle, joinStyle, rectPtr)
 	    TkGetButtPoints(coordPtr+2, coordPtr, width, 0, poly, poly+2);
 
 	    /*
-	     * If the last joint was beveled, then also check a
-	     * polygon comprising the last two points of the previous
-	     * polygon and the first two from this polygon;  this checks
-	     * the wedges that fill the beveled joint.
+	     * If the last joint was beveled, then also check a polygon
+	     * comprising the last two points of the previous polygon and the
+	     * first two from this polygon; this checks the wedges that fill
+	     * the beveled joint.
 	     */
 
 	    if ((joinStyle == JoinBevel) || changedMiterToBevel) {
@@ -403,8 +399,7 @@ TkThickPolyLineToArea(coordPtr, numPoints, width, capStyle, joinStyle, rectPtr)
     }
 
     /*
-     * If caps are rounded, check the cap around the final point
-     * of the line.
+     * If caps are rounded, check the cap around the final point of the line.
      */
 
     if (capStyle == CapRound) {
@@ -428,10 +423,9 @@ TkThickPolyLineToArea(coordPtr, numPoints, width, capStyle, joinStyle, rectPtr)
  *	Compute the distance from a point to a polygon.
  *
  * Results:
- *	The return value is 0.0 if the point referred to by
- *	pointPtr is within the polygon referred to by polyPtr
- *	and numPoints.  Otherwise the return value is the
- *	distance of the point from the polygon.
+ *	The return value is 0.0 if the point referred to by pointPtr is within
+ *	the polygon referred to by polyPtr and numPoints. Otherwise the return
+ *	value is the distance of the point from the polygon.
  *
  * Side effects:
  *	None.
@@ -441,14 +435,14 @@ TkThickPolyLineToArea(coordPtr, numPoints, width, capStyle, joinStyle, rectPtr)
 
 double
 TkPolygonToPoint(polyPtr, numPoints, pointPtr)
-    double *polyPtr;		/* Points to an array coordinates for
-				 * closed polygon:  x0, y0, x1, y1, ...
-				 * The polygon may be self-intersecting. */
+    double *polyPtr;		/* Points to an array coordinates for closed
+				 * polygon: x0, y0, x1, y1, ... The polygon
+				 * may be self-intersecting. */
     int numPoints;		/* Total number of points at *polyPtr. */
     double *pointPtr;		/* Points to coords for point. */
 {
-    double bestDist;		/* Closest distance between point and
-				 * any edge in polygon. */
+    double bestDist;		/* Closest distance between point and any edge
+				 * in polygon. */
     int intersections;		/* Number of edges in the polygon that
 				 * intersect a ray extending vertically
 				 * upwards from the point to infinity. */
@@ -456,13 +450,12 @@ TkPolygonToPoint(polyPtr, numPoints, pointPtr)
     register double *pPtr;
 
     /*
-     * Iterate through all of the edges in the polygon, updating
-     * bestDist and intersections.
+     * Iterate through all of the edges in the polygon, updating bestDist and
+     * intersections.
      *
-     * TRICKY POINT:  when computing intersections, include left
-     * x-coordinate of line within its range, but not y-coordinate.
-     * Otherwise if the point lies exactly below a vertex we'll
-     * count it as two intersections.
+     * TRICKY POINT: when computing intersections, include left x-coordinate
+     * of line within its range, but not y-coordinate. Otherwise if the point
+     * lies exactly below a vertex we'll count it as two intersections.
      */
 
     bestDist = 1.0e36;
@@ -472,10 +465,9 @@ TkPolygonToPoint(polyPtr, numPoints, pointPtr)
 	double x, y, dist;
 
 	/*
-	 * Compute the point on the current edge closest to the point
-	 * and update the intersection count.  This must be done
-	 * separately for vertical edges, horizontal edges, and
-	 * other edges.
+	 * Compute the point on the current edge closest to the point and
+	 * update the intersection count. This must be done separately for
+	 * vertical edges, horizontal edges, and other edges.
 	 */
 
 	if (pPtr[2] == pPtr[0]) {
@@ -516,13 +508,13 @@ TkPolygonToPoint(polyPtr, numPoints, pointPtr)
 	    }
 	} else {
 	    double m1, b1, m2, b2;
-	    int lower;			/* Non-zero means point below line. */
+	    int lower;		/* Non-zero means point below line. */
 
 	    /*
-	     * The edge is neither horizontal nor vertical.  Convert the
-	     * edge to a line equation of the form y = m1*x + b1.  Then
-	     * compute a line perpendicular to this edge but passing
-	     * through the point, also in the form y = m2*x + b2.
+	     * The edge is neither horizontal nor vertical. Convert the edge
+	     * to a line equation of the form y = m1*x + b1. Then compute a
+	     * line perpendicular to this edge but passing through the point,
+	     * also in the form y = m2*x + b2.
 	     */
 
 	    m1 = (pPtr[3] - pPtr[1])/(pPtr[2] - pPtr[0]);
@@ -556,8 +548,8 @@ TkPolygonToPoint(polyPtr, numPoints, pointPtr)
 	}
 
 	/*
-	 * Compute the distance to the closest point, and see if that
-	 * is the best distance seen so far.
+	 * Compute the distance to the closest point, and see if that is the
+	 * best distance seen so far.
 	 */
 
 	dist = hypot(pointPtr[0] - x, pointPtr[1] - y);
@@ -567,8 +559,8 @@ TkPolygonToPoint(polyPtr, numPoints, pointPtr)
     }
 
     /*
-     * We've processed all of the points.  If the number of intersections
-     * is odd, the point is inside the polygon.
+     * We've processed all of the points. If the number of intersections is
+     * odd, the point is inside the polygon.
      */
 
     if (intersections & 0x1) {
@@ -582,14 +574,14 @@ TkPolygonToPoint(polyPtr, numPoints, pointPtr)
  *
  * TkPolygonToArea --
  *
- *	Determine whether a polygon lies entirely inside, entirely
- *	outside, or overlapping a given rectangular area.
+ *	Determine whether a polygon lies entirely inside, entirely outside, or
+ *	overlapping a given rectangular area.
  *
  * Results:
- *	-1 is returned if the polygon given by polyPtr and numPoints
- *	is entirely outside the rectangle given by rectPtr.  0 is
- *	returned if the polygon overlaps the rectangle, and 1 is
- *	returned if the polygon is entirely inside the rectangle.
+ *	-1 is returned if the polygon given by polyPtr and numPoints is
+ *	entirely outside the rectangle given by rectPtr. 0 is returned if the
+ *	polygon overlaps the rectangle, and 1 is returned if the polygon is
+ *	entirely inside the rectangle.
  *
  * Side effects:
  *	None.
@@ -599,13 +591,13 @@ TkPolygonToPoint(polyPtr, numPoints, pointPtr)
 
 int
 TkPolygonToArea(polyPtr, numPoints, rectPtr)
-    double *polyPtr;		/* Points to an array coordinates for
-				 * closed polygon:  x0, y0, x1, y1, ...
-				 * The polygon may be self-intersecting. */
+    double *polyPtr;		/* Points to an array coordinates for closed
+				 * polygon: x0, y0, x1, y1, ... The polygon
+				 * may be self-intersecting. */
     int numPoints;		/* Total number of points at *polyPtr. */
     register double *rectPtr;	/* Points to coords for rectangle, in the
-				 * order x1, y1, x2, y2.  X1 and y1 must
-				 * be lower-left corner. */
+				 * order x1, y1, x2, y2. X1 and y1 must be
+				 * lower-left corner. */
 {
     int state;			/* State of all edges seen so far (-1 means
 				 * outside, 1 means inside, won't ever be
@@ -614,9 +606,8 @@ TkPolygonToArea(polyPtr, numPoints, rectPtr)
     register double *pPtr;
 
     /*
-     * Iterate over all of the edges of the polygon and test them
-     * against the rectangle.  Can quit as soon as the state becomes
-     * "intersecting".
+     * Iterate over all of the edges of the polygon and test them against the
+     * rectangle. Can quit as soon as the state becomes "intersecting".
      */
 
     state = TkLineToArea(polyPtr, polyPtr+2, rectPtr);
@@ -631,10 +622,10 @@ TkPolygonToArea(polyPtr, numPoints, rectPtr)
     }
 
     /*
-     * If all of the edges were inside the rectangle we're done.
-     * If all of the edges were outside, then the rectangle could
-     * still intersect the polygon (if it's entirely enclosed).
-     * Call TkPolygonToPoint to figure this out.
+     * If all of the edges were inside the rectangle we're done. If all of the
+     * edges were outside, then the rectangle could still intersect the
+     * polygon (if it's entirely enclosed). Call TkPolygonToPoint to figure
+     * this out.
      */
 
     if (state == 1) {
@@ -651,17 +642,16 @@ TkPolygonToArea(polyPtr, numPoints, rectPtr)
  *
  * TkOvalToPoint --
  *
- *	Computes the distance from a given point to a given
- *	oval, in canvas units.
+ *	Computes the distance from a given point to a given oval, in canvas
+ *	units.
  *
  * Results:
- *	The return value is 0 if the point given by *pointPtr is
- *	inside the oval.  If the point isn't inside the
- *	oval then the return value is approximately the distance
- *	from the point to the oval.  If the oval is filled, then
- *	anywhere in the interior is considered "inside";  if
- *	the oval isn't filled, then "inside" means only the area
- *	occupied by the outline.
+ *	The return value is 0 if the point given by *pointPtr is inside the
+ *	oval. If the point isn't inside the oval then the return value is
+ *	approximately the distance from the point to the oval. If the oval is
+ *	filled, then anywhere in the interior is considered "inside"; if the
+ *	oval isn't filled, then "inside" means only the area occupied by the
+ *	outline.
  *
  * Side effects:
  *	None.
@@ -672,21 +662,22 @@ TkPolygonToArea(polyPtr, numPoints, rectPtr)
 	/* ARGSUSED */
 double
 TkOvalToPoint(ovalPtr, width, filled, pointPtr)
-    double ovalPtr[4];		/* Pointer to array of four coordinates
-				 * (x1, y1, x2, y2) defining oval's bounding
+    double ovalPtr[4];		/* Pointer to array of four coordinates (x1,
+				 * y1, x2, y2) defining oval's bounding
 				 * box. */
     double width;		/* Width of outline for oval. */
     int filled;			/* Non-zero means oval should be treated as
-				 * filled;  zero means only consider outline. */
+				 * filled; zero means only consider
+				 * outline. */
     double pointPtr[2];		/* Coordinates of point. */
 {
     double xDelta, yDelta, scaledDistance, distToOutline, distToCenter;
     double xDiam, yDiam;
 
     /*
-     * Compute the distance between the center of the oval and the
-     * point in question, using a coordinate system where the oval
-     * has been transformed to a circle with unit radius.
+     * Compute the distance between the center of the oval and the point in
+     * question, using a coordinate system where the oval has been transformed
+     * to a circle with unit radius.
      */
 
     xDelta = (pointPtr[0] - (ovalPtr[0] + ovalPtr[2])/2.0);
@@ -695,16 +686,14 @@ TkOvalToPoint(ovalPtr, width, filled, pointPtr)
     scaledDistance = hypot(xDelta / ((ovalPtr[2] + width - ovalPtr[0])/2.0),
 	    yDelta / ((ovalPtr[3] + width - ovalPtr[1])/2.0));
 
-
     /*
-     * If the scaled distance is greater than 1 then it means no
-     * hit.  Compute the distance from the point to the edge of
-     * the circle, then scale this distance back to the original
-     * coordinate system.
+     * If the scaled distance is greater than 1 then it means no hit. Compute
+     * the distance from the point to the edge of the circle, then scale this
+     * distance back to the original coordinate system.
      *
-     * Note: this distance isn't completely accurate.  It's only
-     * an approximation, and it can overestimate the correct
-     * distance when the oval is eccentric.
+     * Note: this distance isn't completely accurate. It's only an
+     * approximation, and it can overestimate the correct distance when the
+     * oval is eccentric.
      */
 
     if (scaledDistance > 1.0) {
@@ -712,11 +701,11 @@ TkOvalToPoint(ovalPtr, width, filled, pointPtr)
     }
 
     /*
-     * Scaled distance less than 1 means the point is inside the
-     * outer edge of the oval.  If this is a filled oval, then we
-     * have a hit.  Otherwise, do the same computation as above
-     * (scale back to original coordinate system), but also check
-     * to see if the point is within the width of the outline.
+     * Scaled distance less than 1 means the point is inside the outer edge of
+     * the oval. If this is a filled oval, then we have a hit. Otherwise, do
+     * the same computation as above (scale back to original coordinate
+     * system), but also check to see if the point is within the width of the
+     * outline.
      */
 
     if (filled) {
@@ -727,9 +716,9 @@ TkOvalToPoint(ovalPtr, width, filled, pointPtr)
 		- width;
     } else {
 	/*
-	 * Avoid dividing by a very small number (it could cause an
-	 * arithmetic overflow).  This problem occurs if the point is
-	 * very close to the center of the oval.
+	 * Avoid dividing by a very small number (it could cause an arithmetic
+	 * overflow). This problem occurs if the point is very close to the
+	 * center of the oval.
 	 */
 
 	xDiam = ovalPtr[2] - ovalPtr[0];
@@ -752,14 +741,14 @@ TkOvalToPoint(ovalPtr, width, filled, pointPtr)
  *
  * TkOvalToArea --
  *
- *	Determine whether an oval lies entirely inside, entirely
- *	outside, or overlapping a given rectangular area.
+ *	Determine whether an oval lies entirely inside, entirely outside, or
+ *	overlapping a given rectangular area.
  *
  * Results:
- *	-1 is returned if the oval described by ovalPtr is entirely
- *	outside the rectangle given by rectPtr.  0 is returned if the
- *	oval overlaps the rectangle, and 1 is returned if the oval
- *	is entirely inside the rectangle.
+ *	-1 is returned if the oval described by ovalPtr is entirely outside
+ *	the rectangle given by rectPtr. 0 is returned if the oval overlaps the
+ *	rectangle, and 1 is returned if the oval is entirely inside the
+ *	rectangle.
  *
  * Side effects:
  *	None.
@@ -771,17 +760,17 @@ int
 TkOvalToArea(ovalPtr, rectPtr)
     register double *ovalPtr;	/* Points to coordinates definining the
 				 * bounding rectangle for the oval: x1, y1,
-				 * x2, y2.  X1 must be less than x2 and y1
-				 * less than y2. */
+				 * x2, y2. X1 must be less than x2 and y1 less
+				 * than y2. */
     register double *rectPtr;	/* Points to coords for rectangle, in the
-				 * order x1, y1, x2, y2.  X1 and y1 must
-				 * be lower-left corner. */
+				 * order x1, y1, x2, y2. X1 and y1 must be
+				 * lower-left corner. */
 {
     double centerX, centerY, radX, radY, deltaX, deltaY;
 
     /*
-     * First, see if oval is entirely inside rectangle or entirely
-     * outside rectangle.
+     * First, see if oval is entirely inside rectangle or entirely outside
+     * rectangle.
      */
 
     if ((rectPtr[0] <= ovalPtr[0]) && (rectPtr[2] >= ovalPtr[2])
@@ -794,11 +783,10 @@ TkOvalToArea(ovalPtr, rectPtr)
     }
 
     /*
-     * Next, go through the rectangle side by side.  For each side
-     * of the rectangle, find the point on the side that is closest
-     * to the oval's center, and see if that point is inside the
-     * oval.  If at least one such point is inside the oval, then
-     * the rectangle intersects the oval.
+     * Next, go through the rectangle side by side. For each side of the
+     * rectangle, find the point on the side that is closest to the oval's
+     * center, and see if that point is inside the oval. If at least one such
+     * point is inside the oval, then the rectangle intersects the oval.
      */
 
     centerX = (ovalPtr[0] + ovalPtr[2])/2;
@@ -874,8 +862,8 @@ TkOvalToArea(ovalPtr, rectPtr)
  *
  * TkIncludePoint --
  *
- *	Given a point and a generic canvas item header, expand
- *	the item's bounding box if needed to include the point.
+ *	Given a point and a generic canvas item header, expand the item's
+ *	bounding box if needed to include the point.
  *
  * Results:
  *	None.
@@ -889,10 +877,10 @@ TkOvalToArea(ovalPtr, rectPtr)
 	/* ARGSUSED */
 void
 TkIncludePoint(itemPtr, pointPtr)
-    register Tk_Item *itemPtr;		/* Item whose bounding box is
-					 * being calculated. */
-    double *pointPtr;			/* Address of two doubles giving
-					 * x and y coordinates of point. */
+    register Tk_Item *itemPtr;	/* Item whose bounding box is being
+				 * calculated. */
+    double *pointPtr;		/* Address of two doubles giving x and y
+				 * coordinates of point. */
 {
     int tmp;
 
@@ -917,15 +905,14 @@ TkIncludePoint(itemPtr, pointPtr)
  *
  * TkBezierScreenPoints --
  *
- *	Given four control points, create a larger set of XPoints
- *	for a Bezier curve based on the points.
+ *	Given four control points, create a larger set of XPoints for a Bezier
+ *	curve based on the points.
  *
  * Results:
  *	The array at *xPointPtr gets filled in with numSteps XPoints
- *	corresponding to the Bezier spline defined by the four 
- *	control points.  Note:  no output point is generated for the
- *	first input point, but an output point *is* generated for
- *	the last input point.
+ *	corresponding to the Bezier spline defined by the four control points.
+ *	Note: no output point is generated for the first input point, but an
+ *	output point *is* generated for the last input point.
  *
  * Side effects:
  *	None.
@@ -935,14 +922,11 @@ TkIncludePoint(itemPtr, pointPtr)
 
 void
 TkBezierScreenPoints(canvas, control, numSteps, xPointPtr)
-    Tk_Canvas canvas;			/* Canvas in which curve is to be
-					 * drawn. */
-    double control[];			/* Array of coordinates for four
-					 * control points:  x0, y0, x1, y1,
-					 * ... x3 y3. */
-    int numSteps;			/* Number of curve points to
-					 * generate.  */
-    register XPoint *xPointPtr;		/* Where to put new points. */
+    Tk_Canvas canvas;		/* Canvas in which curve is to be drawn. */
+    double control[];		/* Array of coordinates for four control
+				 * points: x0, y0, x1, y1, ... x3 y3. */
+    int numSteps;		/* Number of curve points to generate. */
+    register XPoint *xPointPtr;	/* Where to put new points. */
 {
     int i;
     double u, u2, u3, t, t2, t3;
@@ -968,15 +952,14 @@ TkBezierScreenPoints(canvas, control, numSteps, xPointPtr)
  *
  * TkBezierPoints --
  *
- *	Given four control points, create a larger set of points
- *	for a Bezier curve based on the points.
+ *	Given four control points, create a larger set of points for a Bezier
+ *	curve based on the points.
  *
  * Results:
- *	The array at *coordPtr gets filled in with 2*numSteps
- *	coordinates, which correspond to the Bezier spline defined
- *	by the four control points.  Note:  no output point is
- *	generated for the first input point, but an output point
- *	*is* generated for the last input point.
+ *	The array at *coordPtr gets filled in with 2*numSteps coordinates,
+ *	which correspond to the Bezier spline defined by the four control
+ *	points. Note: no output point is generated for the first input point,
+ *	but an output point *is* generated for the last input point.
  *
  * Side effects:
  *	None.
@@ -986,12 +969,10 @@ TkBezierScreenPoints(canvas, control, numSteps, xPointPtr)
 
 void
 TkBezierPoints(control, numSteps, coordPtr)
-    double control[];			/* Array of coordinates for four
-					 * control points:  x0, y0, x1, y1,
-					 * ... x3 y3. */
-    int numSteps;			/* Number of curve points to
-					 * generate.  */
-    register double *coordPtr;		/* Where to put new points. */
+    double control[];		/* Array of coordinates for four control
+				 * points: x0, y0, x1, y1, ... x3 y3. */
+    int numSteps;		/* Number of curve points to generate. */
+    register double *coordPtr;	/* Where to put new points. */
 {
     int i;
     double u, u2, u3, t, t2, t3;
@@ -1015,22 +996,21 @@ TkBezierPoints(control, numSteps, coordPtr)
  *
  * TkMakeBezierCurve --
  *
- *	Given a set of points, create a new set of points that fit
- *	parabolic splines to the line segments connecting the original
- *	points.  Produces output points in either of two forms.
+ *	Given a set of points, create a new set of points that fit parabolic
+ *	splines to the line segments connecting the original points. Produces
+ *	output points in either of two forms.
  *
- *	Note: the name of this procedure should *not* be taken to 
- *	mean that it interprets the input points as directly defining
- *	Bezier curves.  Rather, it internally computes a Bezier curve
- *	representation of each parabolic spline segment. (These 
- *	Bezier curves are then flattened to produce the points 
- *	filled into the output arrays.)
+ *	Note: the name of this function should *not* be taken to mean that it
+ *	interprets the input points as directly defining Bezier curves.
+ *	Rather, it internally computes a Bezier curve representation of each
+ *	parabolic spline segment. (These Bezier curves are then flattened to
+ *	produce the points filled into the output arrays.)
  *
  * Results:
- *	Either or both of the xPoints or dblPoints arrays are filled
- *	in.  The return value is the number of points placed in the
- *	arrays.  Note:  if the first and last points are the same, then
- *	a closed curve is generated.
+ *	Either or both of the xPoints or dblPoints arrays are filled in. The
+ *	return value is the number of points placed in the arrays. Note: if
+ *	the first and last points are the same, then a closed curve is
+ *	generated.
  *
  * Side effects:
  *	None.
@@ -1040,39 +1020,39 @@ TkBezierPoints(control, numSteps, coordPtr)
 
 int
 TkMakeBezierCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
-    Tk_Canvas canvas;			/* Canvas in which curve is to be
-					 * drawn. */
-    double *pointPtr;			/* Array of input coordinates:  x0,
-					 * y0, x1, y1, etc.. */
-    int numPoints;			/* Number of points at pointPtr. */
-    int numSteps;			/* Number of steps to use for each
-					 * spline segments (determines
-					 * smoothness of curve). */
-    XPoint xPoints[];			/* Array of XPoints to fill in (e.g.
-					 * for display.  NULL means don't
-					 * fill in any XPoints. */
-    double dblPoints[];			/* Array of points to fill in as
-					 * doubles, in the form x0, y0,
-					 * x1, y1, ....  NULL means don't
-					 * fill in anything in this form. 
-					 * Caller must make sure that this
-					 * array has enough space. */
+    Tk_Canvas canvas;		/* Canvas in which curve is to be drawn. */
+    double *pointPtr;		/* Array of input coordinates: x0, y0, x1, y1,
+				 * etc.. */
+    int numPoints;		/* Number of points at pointPtr. */
+    int numSteps;		/* Number of steps to use for each spline
+				 * segments (determines smoothness of
+				 * curve). */
+    XPoint xPoints[];		/* Array of XPoints to fill in (e.g. for
+				 * display). NULL means don't fill in any
+				 * XPoints. */
+    double dblPoints[];		/* Array of points to fill in as doubles, in
+				 * the form x0, y0, x1, y1, .... NULL means
+				 * don't fill in anything in this form.
+				 * Caller must make sure that this array has
+				 * enough space. */
 {
     int closed, outputPoints, i;
     int numCoords = numPoints*2;
     double control[8];
 
     /*
-     * If the curve is a closed one then generate a special spline
-     * that spans the last points and the first ones.  Otherwise
-     * just put the first point into the output.
+     * If the curve is a closed one then generate a special spline that spans
+     * the last points and the first ones. Otherwise just put the first point
+     * into the output.
      */
 
     if (!pointPtr) {
-	/* Of pointPtr == NULL, this function returns an upper limit.
-	 * of the array size to store the coordinates. This can be
-	 * used to allocate storage, before the actual coordinates
-	 * are calculated. */
+	/*
+	 * Of pointPtr == NULL, this function returns an upper limit of the
+	 * array size to store the coordinates. This can be used to allocate
+	 * storage, before the actual coordinates are calculated.
+	 */
+
 	return 1 + numPoints * numSteps;
     }
 
@@ -1118,9 +1098,8 @@ TkMakeBezierCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
 
     for (i = 2; i < numPoints; i++, pointPtr += 2) {
 	/*
-	 * Set up the first two control points.  This is done
-	 * differently for the first spline of an open curve
-	 * than for other cases.
+	 * Set up the first two control points. This is done differently for
+	 * the first spline of an open curve than for other cases.
 	 */
 
 	if ((i == 2) && !closed) {
@@ -1136,9 +1115,8 @@ TkMakeBezierCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
 	}
 
 	/*
-	 * Set up the last two control points.  This is done
-	 * differently for the last spline of an open curve
-	 * than for other cases.
+	 * Set up the last two control points. This is done differently for
+	 * the last spline of an open curve than for other cases.
 	 */
 
 	if ((i == (numPoints-1)) && !closed) {
@@ -1154,10 +1132,9 @@ TkMakeBezierCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
 	}
 
 	/*
-	 * If the first two points coincide, or if the last
-	 * two points coincide, then generate a single
-	 * straight-line segment by outputting the last control
-	 * point.
+	 * If the first two points coincide, or if the last two points
+	 * coincide, then generate a single straight-line segment by
+	 * outputting the last control point.
 	 */
 
 	if (((pointPtr[0] == pointPtr[2]) && (pointPtr[1] == pointPtr[3]))
@@ -1200,15 +1177,14 @@ TkMakeBezierCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
  *
  * TkMakeRawCurve --
  *
- *	Interpret the given set of points as the raw knots and
- *	control points defining a sequence of cubic Bezier curves.
- *	Create a new set of points that fit these Bezier curves.
- *	Output points are produced in either of two forms.
+ *	Interpret the given set of points as the raw knots and control points
+ *	defining a sequence of cubic Bezier curves. Create a new set of points
+ *	that fit these Bezier curves. Output points are produced in either of
+ *	two forms.
  *
  * Results:
- *	Either or both of the xPoints or dblPoints arrays are filled
- *	in.  The return value is the number of points placed in the
- *	arrays.
+ *	Either or both of the xPoints or dblPoints arrays are filled in. The
+ *	return value is the number of points placed in the arrays.
  *
  * Side effects:
  *	None.
@@ -1218,44 +1194,41 @@ TkMakeBezierCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
 
 int
 TkMakeRawCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
-    Tk_Canvas canvas;			/* Canvas in which curve is to be
-					 * drawn. */
-    double *pointPtr;			/* Array of input coordinates:  x0,
-					 * y0, x1, y1, etc.. */
-    int numPoints;			/* Number of points at pointPtr. */
-    int numSteps;			/* Number of steps to use for each
-					 * curve segment (determines
-					 * smoothness of curve). */
-    XPoint xPoints[];			/* Array of XPoints to fill in (e.g.
-					 * for display.  NULL means don't
-					 * fill in any XPoints. */
-    double dblPoints[];			/* Array of points to fill in as
-					 * doubles, in the form x0, y0,
-					 * x1, y1, ....  NULL means don't
-					 * fill in anything in this form.
-					 * Caller must make sure that this
-					 * array has enough space. */
+    Tk_Canvas canvas;		/* Canvas in which curve is to be drawn. */
+    double *pointPtr;		/* Array of input coordinates: x0, y0, x1, y1,
+				 * etc.. */
+    int numPoints;		/* Number of points at pointPtr. */
+    int numSteps;		/* Number of steps to use for each curve
+				 * segment (determines smoothness of
+				 * curve). */
+    XPoint xPoints[];		/* Array of XPoints to fill in (e.g. for
+				 * display). NULL means don't fill in any
+				 * XPoints. */
+    double dblPoints[];		/* Array of points to fill in as doubles, in
+				 * the form x0, y0, x1, y1, .... NULL means
+				 * don't fill in anything in this form.
+				 * Caller must make sure that this array has
+				 * enough space. */
 {
     int outputPoints, i;
     int numSegments = (numPoints+1)/3;
     double *segPtr;
 
     /*
-     * The input describes a curve with s Bezier curve segments if
-     * there are 3s+1, 3s, or 3s-1 input points. In the last two
-     * cases, 1 or 2 initial points from the first curve segment
-     * are reused as defining points also for the last curve segment.
-     * In the case of 3s input points, this will automatically close
-     * the curve.
+     * The input describes a curve with s Bezier curve segments if there are
+     * 3s+1, 3s, or 3s-1 input points. In the last two cases, 1 or 2 initial
+     * points from the first curve segment are reused as defining points also
+     * for the last curve segment. In the case of 3s input points, this will
+     * automatically close the curve.
      */
 
     if (!pointPtr) {
 	/*
-	 * If pointPtr == NULL, this function returns an upper limit.
-	 * of the array size to store the coordinates. This can be
-	 * used to allocate storage, before the actual coordinates
-	 * are calculated.
+	 * If pointPtr == NULL, this function returns an upper limit of the
+	 * array size to store the coordinates. This can be used to allocate
+	 * storage, before the actual coordinates are calculated.
 	 */
+
 	return 1 + numSegments * numSteps;
     }
 
@@ -1273,18 +1246,19 @@ TkMakeRawCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
     outputPoints += 1;
 
     /*
-     * The next loop handles all curve segments except one that
-     * overlaps the end of the list of coordinates.
+     * The next loop handles all curve segments except one that overlaps the
+     * end of the list of coordinates.
      */
 
     for (i=numPoints,segPtr=pointPtr ; i>=4 ; i-=3,segPtr+=6) {
 	if (segPtr[0]==segPtr[2] && segPtr[1]==segPtr[3] &&
 		segPtr[4]==segPtr[6] && segPtr[5]==segPtr[7]) {
 	    /*
-	     * The control points on this segment are equal to
-	     * their neighbouring knots, so this segment is just
-	     * a straight line. A single point is sufficient.
+	     * The control points on this segment are equal to their
+	     * neighbouring knots, so this segment is just a straight line. A
+	     * single point is sufficient.
 	     */
+
 	    if (xPoints != NULL) {
 		Tk_CanvasDrawableCoords(canvas, segPtr[6], segPtr[7],
 			&xPoints->x, &xPoints->y);
@@ -1300,6 +1274,7 @@ TkMakeRawCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
 	    /*
 	     * This is a generic Bezier curve segment.
 	     */
+
 	    if (xPoints != NULL) {
 		TkBezierScreenPoints(canvas, segPtr, numSteps, xPoints);
 		xPoints += numSteps;
@@ -1313,17 +1288,17 @@ TkMakeRawCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
     }
 
     /*
-     * If at this point i>1, then there is some point which has not
-     * yet been used. Make another curve segment.
+     * If at this point i>1, then there is some point which has not yet been
+     * used. Make another curve segment.
      */
 
-    if (i>1) {
+    if (i > 1) {
 	int j;
 	double control[8];
 
 	/*
-	 * Copy the relevant coordinates to control[], so that
-	 * it can be passed as a unit to e.g. TkBezierPoints.
+	 * Copy the relevant coordinates to control[], so that it can be
+	 * passed as a unit to e.g. TkBezierPoints.
 	 */
 
 	for (j=0; j<2*i; j++) {
@@ -1340,10 +1315,11 @@ TkMakeRawCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
 	if (control[0]==control[2] && control[1]==control[3] &&
 		control[4]==control[6] && control[5]==control[7]) {
 	    /*
-	     * The control points on this segment are equal to
-	     * their neighbouring knots, so this segment is just
-	     * a straight line. A single point is sufficient.
+	     * The control points on this segment are equal to their
+	     * neighbouring knots, so this segment is just a straight line. A
+	     * single point is sufficient.
 	     */
+
 	    if (xPoints != NULL) {
 		Tk_CanvasDrawableCoords(canvas, control[6], control[7],
 			&xPoints->x, &xPoints->y);
@@ -1359,6 +1335,7 @@ TkMakeRawCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
 	    /*
 	     * This is a generic Bezier curve segment.
 	     */
+
 	    if (xPoints != NULL) {
 		TkBezierScreenPoints(canvas, control, numSteps, xPoints);
 		xPoints += numSteps;
@@ -1379,12 +1356,12 @@ TkMakeRawCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
  *
  * TkMakeBezierPostscript --
  *
- *	This procedure generates Postscript commands that create
- *	a path corresponding to a given Bezier curve.
+ *	This function generates Postscript commands that create a path
+ *	corresponding to a given Bezier curve.
  *
  * Results:
- *	None.  Postscript commands to generate the path are appended
- *	to the interp's result.
+ *	None. Postscript commands to generate the path are appended to the
+ *	interp's result.
  *
  * Side effects:
  *	None.
@@ -1394,13 +1371,13 @@ TkMakeRawCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
 
 void
 TkMakeBezierPostscript(interp, canvas, pointPtr, numPoints)
-    Tcl_Interp *interp;			/* Interpreter in whose result the
-					 * Postscript is to be stored. */
-    Tk_Canvas canvas;			/* Canvas widget for which the
-					 * Postscript is being generated. */
-    double *pointPtr;			/* Array of input coordinates:  x0,
-					 * y0, x1, y1, etc.. */
-    int numPoints;			/* Number of points at pointPtr. */
+    Tcl_Interp *interp;		/* Interpreter in whose result the Postscript
+				 * is to be stored. */
+    Tk_Canvas canvas;		/* Canvas widget for which the Postscript is
+				 * being generated. */
+    double *pointPtr;		/* Array of input coordinates: x0, y0, x1, y1,
+				 * etc.. */
+    int numPoints;		/* Number of points at pointPtr. */
 {
     int closed, i;
     int numCoords = numPoints*2;
@@ -1408,9 +1385,9 @@ TkMakeBezierPostscript(interp, canvas, pointPtr, numPoints)
     char buffer[200];
 
     /*
-     * If the curve is a closed one then generate a special spline
-     * that spans the last points and the first ones.  Otherwise
-     * just put the first point into the path.
+     * If the curve is a closed one then generate a special spline that spans
+     * the last points and the first ones. Otherwise just put the first point
+     * into the path.
      */
 
     if ((pointPtr[0] == pointPtr[numCoords-2])
@@ -1439,8 +1416,8 @@ TkMakeBezierPostscript(interp, canvas, pointPtr, numPoints)
     Tcl_AppendResult(interp, buffer, (char *) NULL);
 
     /*
-     * Cycle through all the remaining points in the curve, generating
-     * a curve section for each vertex in the linear path.
+     * Cycle through all the remaining points in the curve, generating a curve
+     * section for each vertex in the linear path.
      */
 
     for (i = numPoints-2, pointPtr += 2; i > 0; i--, pointPtr += 2) {
@@ -1448,9 +1425,8 @@ TkMakeBezierPostscript(interp, canvas, pointPtr, numPoints)
 	control[3] = 0.333*control[7] + 0.667*pointPtr[1];
 
 	/*
-	 * Set up the last two control points.  This is done
-	 * differently for the last spline of an open curve
-	 * than for other cases.
+	 * Set up the last two control points. This is done differently for
+	 * the last spline of an open curve than for other cases.
 	 */
 
 	if ((i == 1) && !closed) {
@@ -1476,14 +1452,14 @@ TkMakeBezierPostscript(interp, canvas, pointPtr, numPoints)
  *
  * TkMakeRawCurvePostscript --
  *
- *	This procedure interprets the input points as the raw knot
- *	and control points for a curve composed of Bezier curve
- *	segments, just like TkMakeRawCurve. It generates Postscript
- *	commands that create a path corresponding to this given curve.
+ *	This function interprets the input points as the raw knot and control
+ *	points for a curve composed of Bezier curve segments, just like
+ *	TkMakeRawCurve. It generates Postscript commands that create a path
+ *	corresponding to this given curve.
  *
  * Results:
- *	None.  Postscript commands to generate the path are appended
- *	to the interp's result.
+ *	None. Postscript commands to generate the path are appended to the
+ *	interp's result.
  *
  * Side effects:
  *	None.
@@ -1493,13 +1469,13 @@ TkMakeBezierPostscript(interp, canvas, pointPtr, numPoints)
 
 void
 TkMakeRawCurvePostscript(interp, canvas, pointPtr, numPoints)
-    Tcl_Interp *interp;			/* Interpreter in whose result the
-					 * Postscript is to be stored. */
-    Tk_Canvas canvas;			/* Canvas widget for which the
-					 * Postscript is being generated. */
-    double *pointPtr;			/* Array of input coordinates:  x0,
-					 * y0, x1, y1, etc.. */
-    int numPoints;			/* Number of points at pointPtr. */
+    Tcl_Interp *interp;		/* Interpreter in whose result the Postscript
+				 * is to be stored. */
+    Tk_Canvas canvas;		/* Canvas widget for which the Postscript is
+				 * being generated. */
+    double *pointPtr;		/* Array of input coordinates: x0, y0, x1, y1,
+				 * etc.. */
+    int numPoints;		/* Number of points at pointPtr. */
 {
     int i;
     double *segPtr;
@@ -1514,24 +1490,25 @@ TkMakeRawCurvePostscript(interp, canvas, pointPtr, numPoints)
     Tcl_AppendResult(interp, buffer, (char *) NULL);
 
     /*
-     * Loop through all the remaining points in the curve, generating
-     * a straight line or curve section for every three of them.
+     * Loop through all the remaining points in the curve, generating a
+     * straight line or curve section for every three of them.
      */
 
     for (i=numPoints-1,segPtr=pointPtr ; i>=3 ; i-=3,segPtr+=6) {
 	if (segPtr[0]==segPtr[2] && segPtr[1]==segPtr[3] &&
 		segPtr[4]==segPtr[6] && segPtr[5]==segPtr[7]) {
 	    /*
-	     * The control points on this segment are equal to
-	     * their neighbouring knots, so this segment is just
-	     * a straight line.
+	     * The control points on this segment are equal to their
+	     * neighbouring knots, so this segment is just a straight line.
 	     */
+
 	    sprintf(buffer, "%.15g %.15g lineto\n",
 		    segPtr[6], Tk_CanvasPsY(canvas, segPtr[7]));
 	} else {
 	    /*
 	     * This is a generic Bezier curve segment.
 	     */
+
 	    sprintf(buffer, "%.15g %.15g %.15g %.15g %.15g %.15g curveto\n",
 		    segPtr[2], Tk_CanvasPsY(canvas, segPtr[3]),
 		    segPtr[4], Tk_CanvasPsY(canvas, segPtr[5]),
@@ -1541,12 +1518,11 @@ TkMakeRawCurvePostscript(interp, canvas, pointPtr, numPoints)
     }
 
     /*
-     * If there are any points left that haven't been used,
-     * then build the last segment and generate Postscript in
-     * the same way for that.
+     * If there are any points left that haven't been used, then build the
+     * last segment and generate Postscript in the same way for that.
      */
 
-    if (i>0) {
+    if (i > 0) {
 	int j;
 	double control[8];
 
@@ -1559,11 +1535,17 @@ TkMakeRawCurvePostscript(interp, canvas, pointPtr, numPoints)
 
 	if (control[0]==control[2] && control[1]==control[3] &&
 		control[4]==control[6] && control[5]==control[7]) {
-	    /* Straight line */
+	    /*
+	     * Straight line.
+	     */
+
 	    sprintf(buffer, "%.15g %.15g lineto\n",
 		    control[6], Tk_CanvasPsY(canvas, control[7]));
 	} else {
-	    /* Bezier curve segment */
+	    /*
+	     * Bezier curve segment.
+	     */
+
 	    sprintf(buffer, "%.15g %.15g %.15g %.15g %.15g %.15g curveto\n",
 		    control[2], Tk_CanvasPsY(canvas, control[3]),
 		    control[4], Tk_CanvasPsY(canvas, control[5]),
@@ -1578,16 +1560,14 @@ TkMakeRawCurvePostscript(interp, canvas, pointPtr, numPoints)
  *
  * TkGetMiterPoints --
  *
- *	Given three points forming an angle, compute the
- *	coordinates of the inside and outside points of
- *	the mitered corner formed by a line of a given
- *	width at that angle.
+ *	Given three points forming an angle, compute the coordinates of the
+ *	inside and outside points of the mitered corner formed by a line of a
+ *	given width at that angle.
  *
  * Results:
- *	If the angle formed by the three points is less than
- *	11 degrees then 0 is returned and m1 and m2 aren't
- *	modified.  Otherwise 1 is returned and the points at
- *	m1 and m2 are filled in with the positions of the points
+ *	If the angle formed by the three points is less than 11 degrees then 0
+ *	is returned and m1 and m2 aren't modified. Otherwise 1 is returned and
+ *	the points at m1 and m2 are filled in with the positions of the points
  *	of the mitered corner.
  *
  * Side effects:
@@ -1604,29 +1584,28 @@ TkGetMiterPoints(p1, p2, p3, width, m1, m2)
 				 * for mitered joint. */
     double p3[];		/* Points to x- and y-coordinates of point
 				 * after vertex. */
-    double width;		/* Width of line.  */
-    double m1[];		/* Points to place to put "left" vertex
-				 * point (see as you face from p1 to p2). */
+    double width;		/* Width of line. */
+    double m1[];		/* Points to place to put "left" vertex point
+				 * (see as you face from p1 to p2). */
     double m2[];		/* Points to place to put "right" vertex
 				 * point. */
 {
     double theta1;		/* Angle of segment p2-p1. */
     double theta2;		/* Angle of segment p2-p3. */
-    double theta;		/* Angle between line segments (angle
-				 * of joint). */
-    double theta3;		/* Angle that bisects theta1 and
-				 * theta2 and points to m1. */
+    double theta;		/* Angle between line segments (angle of
+				 * joint). */
+    double theta3;		/* Angle that bisects theta1 and theta2 and
+				 * points to m1. */
     double dist;		/* Distance of miter points from p2. */
-    double deltaX, deltaY;	/* X and y offsets cooresponding to
-				 * dist (fudge factors for bounding
-				 * box). */
+    double deltaX, deltaY;	/* X and y offsets cooresponding to dist
+				 * (fudge factors for bounding box). */
     double p1x, p1y, p2x, p2y, p3x, p3y;
     static double elevenDegrees = (11.0*2.0*PI)/360.0;
 
     /*
-     * Round the coordinates to integers to mimic what happens when the
-     * line segments are displayed; without this code, the bounding box
-     * of a mitered line can be miscomputed greatly.
+     * Round the coordinates to integers to mimic what happens when the line
+     * segments are displayed; without this code, the bounding box of a
+     * mitered line can be miscomputed greatly.
      */
 
     p1x = floor(p1[0]+0.5);
@@ -1643,6 +1622,7 @@ TkGetMiterPoints(p1, p2, p3, width, m1, m2)
     } else {
 	theta1 = atan2(p1y - p2y, p1x - p2x);
     }
+
     if (p3y == p2y) {
 	theta2 = (p3x > p2x) ? 0 : PI;
     } else if (p3x == p2x) {
@@ -1650,23 +1630,26 @@ TkGetMiterPoints(p1, p2, p3, width, m1, m2)
     } else {
 	theta2 = atan2(p3y - p2y, p3x - p2x);
     }
+
     theta = theta1 - theta2;
     if (theta > PI) {
 	theta -= 2*PI;
     } else if (theta < -PI) {
 	theta += 2*PI;
     }
+
     if ((theta < elevenDegrees) && (theta > -elevenDegrees)) {
 	return 0;
     }
+
     dist = 0.5*width/sin(0.5*theta);
     if (dist < 0.0) {
 	dist = -dist;
     }
 
     /*
-     * Compute theta3 (make sure that it points to the left when
-     * looking from p1 to p2).
+     * Compute theta3 (make sure that it points to the left when looking from
+     * p1 to p2).
      */
 
     theta3 = (theta1 + theta2)/2.0;
@@ -1679,6 +1662,7 @@ TkGetMiterPoints(p1, p2, p3, width, m1, m2)
     deltaY = dist*sin(theta3);
     m1[1] = p2y + deltaY;
     m2[1] = p2y - deltaY;
+
     return 1;
 }
 
@@ -1687,13 +1671,13 @@ TkGetMiterPoints(p1, p2, p3, width, m1, m2)
  *
  * TkGetButtPoints --
  *
- *	Given two points forming a line segment, compute the
- *	coordinates of two endpoints of a rectangle formed by
- *	bloating the line segment until it is width units wide.
+ *	Given two points forming a line segment, compute the coordinates of
+ *	two endpoints of a rectangle formed by bloating the line segment until
+ *	it is width units wide.
  *
  * Results:
- *	There is no return value.  M1 and m2 are filled in to
- *	correspond to m1 and m2 in the diagram below:
+ *	There is no return value. M1 and m2 are filled in to correspond to m1
+ *	and m2 in the diagram below:
  *
  *		   ----------------* m1
  *				   |
@@ -1701,9 +1685,9 @@ TkGetMiterPoints(p1, p2, p3, width, m1, m2)
  *				   |
  *		   ----------------* m2
  *
- *	M1 and m2 will be W units apart, with p2 centered between
- *	them and m1-m2 perpendicular to p1-p2.  However, if
- *	"project" is true then m1 and m2 will be as follows:
+ *	M1 and m2 will be W units apart, with p2 centered between them and
+ *	m1-m2 perpendicular to p1-p2. However, if "project" is true then m1
+ *	and m2 will be as follows:
  *
  *		   -------------------* m1
  *				  p2  |
@@ -1725,11 +1709,11 @@ TkGetButtPoints(p1, p2, width, project, m1, m2)
 				 * before vertex. */
     double p2[];		/* Points to x- and y-coordinates of vertex
 				 * for mitered joint. */
-    double width;		/* Width of line.  */
+    double width;		/* Width of line. */
     int project;		/* Non-zero means project p2 by an additional
 				 * width/2 before computing m1 and m2. */
-    double m1[];		/* Points to place to put "left" result
-				 * point, as you face from p1 to p2. */
+    double m1[];		/* Points to place to put "left" result point,
+				 * as you face from p1 to p2. */
     double m2[];		/* Points to place to put "right" result
 				 * point. */
 {
@@ -1756,3 +1740,11 @@ TkGetButtPoints(p1, p2, width, project, m1, m2)
 	}
     }
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */