ANSIfy

1 files changed, 318 insertions, 334 deletions

diff --git a/generic/tk3d.c b/generic/tk3d.c
index dc69662..f85d54c 100644
--- a/generic/tk3d.c
+++ b/generic/tk3d.c
@@ -1,42 +1,42 @@
-/* 
+/*
  * tk3d.c --
  *
- *	This module provides procedures to draw borders in
- *	the three-dimensional Motif style.
+ *	This module provides procedures to draw borders in the
+ *	three-dimensional Motif style.
  *
  * Copyright (c) 1990-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: tk3d.c,v 1.14 2004/01/13 02:06:00 davygrvy Exp $
+ * RCS: @(#) $Id: tk3d.c,v 1.15 2005/11/04 11:52:50 dkf Exp $
  */
 
 #include "tk3d.h"
 
 /*
- * The following table defines the string values for reliefs, which are
- * used by Tk_GetReliefFromObj.
+ * The following table defines the string values for reliefs, which are used
+ * by Tk_GetReliefFromObj.
  */
 
-static CONST char *reliefStrings[] = {"flat", "groove", "raised",
-				    "ridge", "solid", "sunken", 
-				    (char *) NULL};
+static CONST char *reliefStrings[] = {
+    "flat", "groove", "raised", "ridge", "solid", "sunken", NULL
+};
 
 /*
- * Forward declarations for procedures defined in this file:
+ * Forward declarations for functions defined in this file:
  */
 
-static void		BorderInit _ANSI_ARGS_((TkDisplay *dispPtr));
-static void		DupBorderObjProc _ANSI_ARGS_((Tcl_Obj *srcObjPtr,
-			    Tcl_Obj *dupObjPtr));
-static void		FreeBorderObjProc _ANSI_ARGS_((Tcl_Obj *objPtr));
-static int		Intersect _ANSI_ARGS_((XPoint *a1Ptr, XPoint *a2Ptr,
-			    XPoint *b1Ptr, XPoint *b2Ptr, XPoint *iPtr));
-static void		InitBorderObj _ANSI_ARGS_((Tcl_Obj *objPtr));
-static void		ShiftLine _ANSI_ARGS_((XPoint *p1Ptr, XPoint *p2Ptr,
-			    int distance, XPoint *p3Ptr));
+static void		BorderInit(TkDisplay *dispPtr);
+static void		DupBorderObjProc(Tcl_Obj *srcObjPtr,
+			    Tcl_Obj *dupObjPtr);
+static void		FreeBorderObjProc(Tcl_Obj *objPtr);
+static int		Intersect(XPoint *a1Ptr, XPoint *a2Ptr,
+			    XPoint *b1Ptr, XPoint *b2Ptr, XPoint *iPtr);
+static void		InitBorderObj(Tcl_Obj *objPtr);
+static void		ShiftLine(XPoint *p1Ptr, XPoint *p2Ptr,
+			    int distance, XPoint *p3Ptr);
 
 /*
  * The following structure defines the implementation of the "border" Tcl
@@ -59,30 +59,30 @@ Tcl_ObjType tkBorderObjType = {
  *
  * Tk_Alloc3DBorderFromObj --
  *
- *	Given a Tcl_Obj *, map the value to a corresponding
- *	Tk_3DBorder structure based on the tkwin given.
+ *	Given a Tcl_Obj *, map the value to a corresponding Tk_3DBorder
+ *	structure based on the tkwin given.
  *
  * Results:
- *	The return value is a token for a data structure describing a
- *	3-D border.  This token may be passed to procedures such as
- *	Tk_Draw3DRectangle and Tk_Free3DBorder.  If an error prevented
- *	the border from being created then NULL is returned and an error
- *	message will be left in the interp's result.
+ *	The return value is a token for a data structure describing a 3-D
+ *	border. This token may be passed to functions such as
+ *	Tk_Draw3DRectangle and Tk_Free3DBorder. If an error prevented the
+ *	border from being created then NULL is returned and an error message
+ *	will be left in the interp's result.
  *
  * Side effects:
- *	The border is added to an internal database with a reference
- *	count. For each call to this procedure, there should eventually
- *	be a call to FreeBorderObjProc so that the database is
- *	cleaned up when borders aren't in use anymore.
+ *	The border is added to an internal database with a reference count.
+ *	For each call to this function, there should eventually be a call to
+ *	FreeBorderObjProc so that the database is cleaned up when borders
+ *	aren't in use anymore.
  *
  *----------------------------------------------------------------------
  */
 
 Tk_3DBorder
-Tk_Alloc3DBorderFromObj(interp, tkwin, objPtr)
-    Tcl_Interp *interp;		/* Interp for error results. */
-    Tk_Window tkwin;		/* Need the screen the border is used on.*/
-    Tcl_Obj *objPtr;		/* Object giving name of color for window
+Tk_Alloc3DBorderFromObj(
+    Tcl_Interp *interp,		/* Interp for error results. */
+    Tk_Window tkwin,		/* Need the screen the border is used on.*/
+    Tcl_Obj *objPtr)		/* Object giving name of color for window
 				 * background. */
 {
     TkBorder *borderPtr;
@@ -93,15 +93,15 @@ Tk_Alloc3DBorderFromObj(interp, tkwin, objPtr)
     borderPtr = (TkBorder *) objPtr->internalRep.twoPtrValue.ptr1;
 
     /*
-     * If the object currently points to a TkBorder, see if it's the
-     * one we want.  If so, increment its reference count and return.
+     * If the object currently points to a TkBorder, see if it's the one we
+     * want. If so, increment its reference count and return.
      */
 
     if (borderPtr != NULL) {
 	if (borderPtr->resourceRefCount == 0) {
 	    /*
-	     * This is a stale reference: it refers to a border that's
-	     * no longer in use.  Clear the reference.
+	     * This is a stale reference: it refers to a border that's no
+	     * longer in use. Clear the reference.
 	     */
 
 	    FreeBorderObjProc(objPtr);
@@ -114,24 +114,22 @@ Tk_Alloc3DBorderFromObj(interp, tkwin, objPtr)
     }
 
     /*
-     * The object didn't point to the border that we wanted.  Search
-     * the list of borders with the same name to see if one of the
-     * others is the right one.
+     * The object didn't point to the border that we wanted. Search the list
+     * of borders with the same name to see if one of the others is the right
+     * one.
      */
 
     /*
-     * If the cached value is NULL, either the object type was not a
-     * color going in, or the object is a color type but had
-     * previously been freed.
+     * If the cached value is NULL, either the object type was not a color
+     * going in, or the object is a color type but had previously been freed.
      *
-     * If the value is not NULL, the internal rep is the value
-     * of the color the last time this object was accessed. Check
-     * the screen and colormap of the last access, and if they
-     * match, we are done.
+     * If the value is not NULL, the internal rep is the value of the color
+     * the last time this object was accessed. Check the screen and colormap
+     * of the last access, and if they match, we are done.
      */
 
     if (borderPtr != NULL) {
-	TkBorder *firstBorderPtr = 
+	TkBorder *firstBorderPtr =
 		(TkBorder *) Tcl_GetHashValue(borderPtr->hashPtr);
 	FreeBorderObjProc(objPtr);
 	for (borderPtr = firstBorderPtr ; borderPtr != NULL;
@@ -140,19 +138,19 @@ Tk_Alloc3DBorderFromObj(interp, tkwin, objPtr)
 		&& (Tk_Colormap(tkwin) == borderPtr->colormap)) {
 		borderPtr->resourceRefCount++;
 		borderPtr->objRefCount++;
-		objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) borderPtr;
+		objPtr->internalRep.twoPtrValue.ptr1 = (void *) borderPtr;
 		return (Tk_3DBorder) borderPtr;
 	    }
 	}
     }
 
     /*
-     * Still no luck.  Call Tk_Get3DBorder to allocate a new border.
+     * Still no luck. Call Tk_Get3DBorder to allocate a new border.
      */
 
     borderPtr = (TkBorder *) Tk_Get3DBorder(interp, tkwin,
 	    Tcl_GetString(objPtr));
-    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) borderPtr;
+    objPtr->internalRep.twoPtrValue.ptr1 = (void *) borderPtr;
     if (borderPtr != NULL) {
 	borderPtr->objRefCount++;
     }
@@ -167,27 +165,27 @@ Tk_Alloc3DBorderFromObj(interp, tkwin, objPtr)
  *	Create a data structure for displaying a 3-D border.
  *
  * Results:
- *	The return value is a token for a data structure describing a
- *	3-D border.  This token may be passed to procedures such as
- *	Tk_Draw3DRectangle and Tk_Free3DBorder.  If an error prevented
- *	the border from being created then NULL is returned and an error
- *	message will be left in the interp's result.
+ *	The return value is a token for a data structure describing a 3-D
+ *	border. This token may be passed to functions such as
+ *	Tk_Draw3DRectangle and Tk_Free3DBorder. If an error prevented the
+ *	border from being created then NULL is returned and an error message
+ *	will be left in the interp's result.
  *
  * Side effects:
- *	Data structures, graphics contexts, etc. are allocated.
- *	It is the caller's responsibility to eventually call
- *	Tk_Free3DBorder to release the resources.
+ *	Data structures, graphics contexts, etc. are allocated. It is the
+ *	caller's responsibility to eventually call Tk_Free3DBorder to release
+ *	the resources.
  *
  *--------------------------------------------------------------
  */
 
 Tk_3DBorder
-Tk_Get3DBorder(interp, tkwin, colorName)
-    Tcl_Interp *interp;		/* Place to store an error message. */
-    Tk_Window tkwin;		/* Token for window in which border will
-				 * be drawn. */
-    Tk_Uid colorName;		/* String giving name of color
-				 * for window background. */
+Tk_Get3DBorder(
+    Tcl_Interp *interp,		/* Place to store an error message. */
+    Tk_Window tkwin,		/* Token for window in which border will be
+				 * drawn. */
+    Tk_Uid colorName)		/* String giving name of color for window
+				 * background. */
 {
     Tcl_HashEntry *hashPtr;
     TkBorder *borderPtr, *existingBorderPtr;
@@ -218,7 +216,7 @@ Tk_Get3DBorder(interp, tkwin, colorName)
     }
 
     /*
-     * No satisfactory border exists yet.  Initialize a new one.
+     * No satisfactory border exists yet. Initialize a new one.
      */
 
     bgColorPtr = Tk_GetColor(interp, tkwin, colorName);
@@ -248,9 +246,8 @@ Tk_Get3DBorder(interp, tkwin, colorName)
     Tcl_SetHashValue(hashPtr, borderPtr);
 
     /*
-     * Create the information for displaying the background color,
-     * but delay the allocation of shadows until they are actually
-     * needed for drawing.
+     * Create the information for displaying the background color, but delay
+     * the allocation of shadows until they are actually needed for drawing.
      */
 
     gcValues.foreground = borderPtr->bgColorPtr->pixel;
@@ -269,25 +266,24 @@ Tk_Get3DBorder(interp, tkwin, colorName)
  *	None.
  *
  * Side effects:
- *	A 3-D border will be drawn in the indicated drawable.
- *	The outside edges of the border will be determined by x,
- *	y, width, and height.  The inside edges of the border
- *	will be determined by the borderWidth argument.
+ *	A 3-D border will be drawn in the indicated drawable. The outside
+ *	edges of the border will be determined by x, y, width, and height. The
+ *	inside edges of the border will be determined by the borderWidth
+ *	argument.
  *
  *--------------------------------------------------------------
  */
 
 void
-Tk_Draw3DRectangle(tkwin, drawable, border, x, y, width, height,
-	borderWidth, relief)
-    Tk_Window tkwin;		/* Window for which border was allocated. */
-    Drawable drawable;		/* X window or pixmap in which to draw. */
-    Tk_3DBorder border;		/* Token for border to draw. */
-    int x, y, width, height;	/* Outside area of region in
-				 * which border will be drawn. */
-    int borderWidth;		/* Desired width for border, in
-				 * pixels. */
-    int relief;			/* Type of relief: TK_RELIEF_RAISED,
+Tk_Draw3DRectangle(
+    Tk_Window tkwin,		/* Window for which border was allocated. */
+    Drawable drawable,		/* X window or pixmap in which to draw. */
+    Tk_3DBorder border,		/* Token for border to draw. */
+    int x, int y, int width, int height,
+				/* Outside area of region in which border will
+				 * be drawn. */
+    int borderWidth,		/* Desired width for border, in pixels. */
+    int relief)			/* Type of relief: TK_RELIEF_RAISED,
 				 * TK_RELIEF_SUNKEN, TK_RELIEF_GROOVE, etc. */
 {
     if (width < 2*borderWidth) {
@@ -311,12 +307,11 @@ Tk_Draw3DRectangle(tkwin, drawable, border, x, y, width, height,
  *
  * Tk_NameOf3DBorder --
  *
- *	Given a border, return a textual string identifying the
- *	border's color.
+ *	Given a border, return a textual string identifying the border's
+ *	color.
  *
  * Results:
- *	The return value is the string that was used to create
- *	the border.
+ *	The return value is the string that was used to create the border.
  *
  * Side effects:
  *	None.
@@ -325,8 +320,8 @@ Tk_Draw3DRectangle(tkwin, drawable, border, x, y, width, height,
  */
 
 CONST char *
-Tk_NameOf3DBorder(border)
-    Tk_3DBorder border;		/* Token for border. */
+Tk_NameOf3DBorder(
+    Tk_3DBorder border)		/* Token for border. */
 {
     TkBorder *borderPtr = (TkBorder *) border;
 
@@ -338,8 +333,7 @@ Tk_NameOf3DBorder(border)
  *
  * Tk_3DBorderColor --
  *
- *	Given a 3D border, return the X color used for the "flat"
- *	surfaces.
+ *	Given a 3D border, return the X color used for the "flat" surfaces.
  *
  * Results:
  *	Returns the color used drawing flat surfaces with the border.
@@ -350,10 +344,10 @@ Tk_NameOf3DBorder(border)
  *--------------------------------------------------------------------
  */
 XColor *
-Tk_3DBorderColor(border)
-    Tk_3DBorder border;		/* Border whose color is wanted. */
+Tk_3DBorderColor(
+    Tk_3DBorder border)		/* Border whose color is wanted. */
 {
-    return(((TkBorder *) border)->bgColorPtr);
+    return ((TkBorder *) border)->bgColorPtr;
 }
 
 /*
@@ -361,8 +355,8 @@ Tk_3DBorderColor(border)
  *
  * Tk_3DBorderGC --
  *
- *	Given a 3D border, returns one of the graphics contexts used to
- *	draw the border.
+ *	Given a 3D border, returns one of the graphics contexts used to draw
+ *	the border.
  *
  * Results:
  *	Returns the graphics context given by the "which" argument.
@@ -373,10 +367,10 @@ Tk_3DBorderColor(border)
  *--------------------------------------------------------------------
  */
 GC
-Tk_3DBorderGC(tkwin, border, which)
-    Tk_Window tkwin;		/* Window for which border was allocated. */
-    Tk_3DBorder border;		/* Border whose GC is wanted. */
-    int which;			/* Selects one of the border's 3 GC's:
+Tk_3DBorderGC(
+    Tk_Window tkwin,		/* Window for which border was allocated. */
+    Tk_3DBorder border,		/* Border whose GC is wanted. */
+    int which)			/* Selects one of the border's 3 GC's:
 				 * TK_3D_FLAT_GC, TK_3D_LIGHT_GC, or
 				 * TK_3D_DARK_GC. */
 {
@@ -395,8 +389,8 @@ Tk_3DBorderGC(tkwin, border, which)
     Tcl_Panic("bogus \"which\" value in Tk_3DBorderGC");
 
     /*
-     * The code below will never be executed, but it's needed to
-     * keep compilers happy.
+     * The code below will never be executed, but it's needed to keep
+     * compilers happy.
      */
 
     return (GC) None;
@@ -407,10 +401,9 @@ Tk_3DBorderGC(tkwin, border, which)
  *
  * Tk_Free3DBorder --
  *
- *	This procedure is called when a 3D border is no longer
- *	needed.  It frees the resources associated with the
- *	border.  After this call, the caller should never again
- *	use the "border" token.
+ *	This function is called when a 3D border is no longer needed. It frees
+ *	the resources associated with the border. After this call, the caller
+ *	should never again use the "border" token.
  *
  * Results:
  *	None.
@@ -422,8 +415,8 @@ Tk_3DBorderGC(tkwin, border, which)
  */
 
 void
-Tk_Free3DBorder(border)
-    Tk_3DBorder border;		/* Token for border to be released. */
+Tk_Free3DBorder(
+    Tk_3DBorder border)		/* Token for border to be released. */
 {
     TkBorder *borderPtr = (TkBorder *) border;
     Display *display = DisplayOfScreen(borderPtr->screen);
@@ -479,27 +472,27 @@ Tk_Free3DBorder(border)
  *
  * Tk_Free3DBorderFromObj --
  *
- *	This procedure is called to release a border allocated by
- *	Tk_Alloc3DBorderFromObj. It does not throw away the Tcl_Obj *;
- *	it only gets rid of the hash table entry for this border
- *	and clears the cached value that is normally stored in the object.
+ *	This function is called to release a border allocated by
+ *	Tk_Alloc3DBorderFromObj. It does not throw away the Tcl_Obj *; it only
+ *	gets rid of the hash table entry for this border and clears the cached
+ *	value that is normally stored in the object.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The reference count associated with the border represented by
- *	objPtr is decremented, and the border's resources are released 
- *	to X if there are no remaining uses for it.
+ *	The reference count associated with the border represented by objPtr
+ *	is decremented, and the border's resources are released to X if there
+ *	are no remaining uses for it.
  *
  *----------------------------------------------------------------------
  */
 
 void
-Tk_Free3DBorderFromObj(tkwin, objPtr)
-    Tk_Window tkwin;		/* The window this border lives in. Needed
-				 * for the screen and colormap values. */
-    Tcl_Obj *objPtr;		/* The Tcl_Obj * to be freed. */
+Tk_Free3DBorderFromObj(
+    Tk_Window tkwin,		/* The window this border lives in. Needed for
+				 * the screen and colormap values. */
+    Tcl_Obj *objPtr)		/* The Tcl_Obj * to be freed. */
 {
     Tk_Free3DBorder(Tk_Get3DBorderFromObj(tkwin, objPtr));
     FreeBorderObjProc(objPtr);
@@ -508,66 +501,65 @@ Tk_Free3DBorderFromObj(tkwin, objPtr)
 /*
  *---------------------------------------------------------------------------
  *
- * FreeBorderObjProc -- 
+ * FreeBorderObjProc --
  *
- *	This proc is called to release an object reference to a border.
- *	Called when the object's internal rep is released or when
- *	the cached borderPtr needs to be changed.
+ *	This proc is called to release an object reference to a border. Called
+ *	when the object's internal rep is released or when the cached
+ *	borderPtr needs to be changed.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The object reference count is decremented. When both it
- *	and the hash ref count go to zero, the border's resources
- *	are released.
+ *	The object reference count is decremented. When both it and the hash
+ *	ref count go to zero, the border's resources are released.
  *
  *---------------------------------------------------------------------------
  */
 
 static void
-FreeBorderObjProc(objPtr)
-    Tcl_Obj *objPtr;		/* The object we are releasing. */
+FreeBorderObjProc(
+    Tcl_Obj *objPtr)		/* The object we are releasing. */
 {
     TkBorder *borderPtr = (TkBorder *) objPtr->internalRep.twoPtrValue.ptr1;
 
     if (borderPtr != NULL) {
 	borderPtr->objRefCount--;
-	if ((borderPtr->objRefCount == 0) 
+	if ((borderPtr->objRefCount == 0)
 		&& (borderPtr->resourceRefCount == 0)) {
 	    ckfree((char *) borderPtr);
 	}
-	objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) NULL;
+	objPtr->internalRep.twoPtrValue.ptr1 = NULL;
     }
 }
 
 /*
  *---------------------------------------------------------------------------
  *
- * DupBorderObjProc -- 
+ * DupBorderObjProc --
  *
- *	When a cached border object is duplicated, this is called to
- *	update the internal reps.
+ *	When a cached border object is duplicated, this is called to update
+ *	the internal reps.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The border's objRefCount is incremented and the internal rep
- *	of the copy is set to point to it.
+ *	The border's objRefCount is incremented and the internal rep of the
+ *	copy is set to point to it.
  *
  *---------------------------------------------------------------------------
  */
 
 static void
-DupBorderObjProc(srcObjPtr, dupObjPtr)
-    Tcl_Obj *srcObjPtr;		/* The object we are copying from. */
-    Tcl_Obj *dupObjPtr;		/* The object we are copying to. */
+DupBorderObjProc(
+    Tcl_Obj *srcObjPtr,		/* The object we are copying from. */
+    Tcl_Obj *dupObjPtr)		/* The object we are copying to. */
 {
     TkBorder *borderPtr = (TkBorder *) srcObjPtr->internalRep.twoPtrValue.ptr1;
-    
+
     dupObjPtr->typePtr = srcObjPtr->typePtr;
-    dupObjPtr->internalRep.twoPtrValue.ptr1 = (VOID *) borderPtr;
+    dupObjPtr->internalRep.twoPtrValue.ptr1 = (void *) borderPtr;
 
     if (borderPtr != NULL) {
 	borderPtr->objRefCount++;
@@ -579,8 +571,8 @@ DupBorderObjProc(srcObjPtr, dupObjPtr)
  *
  * Tk_SetBackgroundFromBorder --
  *
- *	Change the background of a window to one appropriate for a given
- *	3-D border.
+ *	Change the background of a window to one appropriate for a given 3-D
+ *	border.
  *
  * Results:
  *	None.
@@ -592,9 +584,9 @@ DupBorderObjProc(srcObjPtr, dupObjPtr)
  */
 
 void
-Tk_SetBackgroundFromBorder(tkwin, border)
-    Tk_Window tkwin;		/* Window whose background is to be set. */
-    Tk_3DBorder border;		/* Token for border. */
+Tk_SetBackgroundFromBorder(
+    Tk_Window tkwin,		/* Window whose background is to be set. */
+    Tk_3DBorder border)		/* Token for border. */
 {
     register TkBorder *borderPtr = (TkBorder *) border;
 
@@ -620,13 +612,13 @@ Tk_SetBackgroundFromBorder(tkwin, border)
  */
 
 int
-Tk_GetReliefFromObj(interp, objPtr, resultPtr)
-    Tcl_Interp *interp;		/* Used for error reporting. */
-    Tcl_Obj *objPtr;		/* The object we are trying to get the 
-				 * value from. */
-    int *resultPtr;		/* Where to place the answer. */
+Tk_GetReliefFromObj(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    Tcl_Obj *objPtr,		/* The object we are trying to get the value
+				 * from. */
+    int *resultPtr)		/* Where to place the answer. */
 {
-    return Tcl_GetIndexFromObj(interp, objPtr, reliefStrings, "relief", 0, 
+    return Tcl_GetIndexFromObj(interp, objPtr, reliefStrings, "relief", 0,
 	    resultPtr);
 }
 
@@ -635,13 +627,13 @@ Tk_GetReliefFromObj(interp, objPtr, resultPtr)
  *
  * Tk_GetRelief --
  *
- *	Parse a relief description and return the corresponding
- *	relief value, or an error.
+ *	Parse a relief description and return the corresponding relief value,
+ *	or an error.
  *
  * Results:
- *	A standard Tcl return value.  If all goes well then
- *	*reliefPtr is filled in with one of the values
- *	TK_RELIEF_RAISED, TK_RELIEF_FLAT, or TK_RELIEF_SUNKEN.
+ *	A standard Tcl return value. If all goes well then *reliefPtr is
+ *	filled in with one of the values TK_RELIEF_RAISED, TK_RELIEF_FLAT, or
+ *	TK_RELIEF_SUNKEN.
  *
  * Side effects:
  *	None.
@@ -650,10 +642,10 @@ Tk_GetReliefFromObj(interp, objPtr, resultPtr)
  */
 
 int
-Tk_GetRelief(interp, name, reliefPtr)
-    Tcl_Interp *interp;		/* For error messages. */
-    CONST char *name;		/* Name of a relief type. */
-    int *reliefPtr;		/* Where to store converted relief. */
+Tk_GetRelief(
+    Tcl_Interp *interp,		/* For error messages. */
+    CONST char *name,		/* Name of a relief type. */
+    int *reliefPtr)		/* Where to store converted relief. */
 {
     char c;
     size_t length;
@@ -690,12 +682,10 @@ Tk_GetRelief(interp, name, reliefPtr)
  *
  * Tk_NameOfRelief --
  *
- *	Given a relief value, produce a string describing that
- *	relief value.
+ *	Given a relief value, produce a string describing that relief value.
  *
  * Results:
- *	The return value is a static string that is equivalent
- *	to relief.
+ *	The return value is a static string that is equivalent to relief.
  *
  * Side effects:
  *	None.
@@ -704,9 +694,9 @@ Tk_GetRelief(interp, name, reliefPtr)
  */
 
 CONST char *
-Tk_NameOfRelief(relief)
-    int relief;		/* One of TK_RELIEF_FLAT, TK_RELIEF_RAISED,
-			 * or TK_RELIEF_SUNKEN. */
+Tk_NameOfRelief(
+    int relief)		/* One of TK_RELIEF_FLAT, TK_RELIEF_RAISED, or
+			 * TK_RELIEF_SUNKEN. */
 {
     if (relief == TK_RELIEF_FLAT) {
 	return "flat";
@@ -732,39 +722,35 @@ Tk_NameOfRelief(relief)
  *
  * Tk_Draw3DPolygon --
  *
- *	Draw a border with 3-D appearance around the edge of a
- *	given polygon.
+ *	Draw a border with 3-D appearance around the edge of a given polygon.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Information is drawn in "drawable" in the form of a
- *	3-D border borderWidth units width wide on the left
- *	of the trajectory given by pointPtr and numPoints (or
- *	-borderWidth units wide on the right side, if borderWidth
- *	is negative).
+ *	Information is drawn in "drawable" in the form of a 3-D border
+ *	borderWidth units width wide on the left of the trajectory given by
+ *	pointPtr and numPoints (or -borderWidth units wide on the right side,
+ *	if borderWidth is negative).
  *
  *--------------------------------------------------------------
  */
 
 void
-Tk_Draw3DPolygon(tkwin, drawable, border, pointPtr, numPoints,
-	borderWidth, leftRelief)
-    Tk_Window tkwin;		/* Window for which border was allocated. */
-    Drawable drawable;		/* X window or pixmap in which to draw. */
-    Tk_3DBorder border;		/* Token for border to draw. */
-    XPoint *pointPtr;		/* Array of points describing
-				 * polygon.  All points must be
-				 * absolute (CoordModeOrigin). */
-    int numPoints;		/* Number of points at *pointPtr. */
-    int borderWidth;		/* Width of border, measured in
-				 * pixels to the left of the polygon's
-				 * trajectory.   May be negative. */
-    int leftRelief;		/* TK_RELIEF_RAISED or
-				 * TK_RELIEF_SUNKEN: indicates how
-				 * stuff to left of trajectory looks
-				 * relative to stuff on right. */
+Tk_Draw3DPolygon(
+    Tk_Window tkwin,		/* Window for which border was allocated. */
+    Drawable drawable,		/* X window or pixmap in which to draw. */
+    Tk_3DBorder border,		/* Token for border to draw. */
+    XPoint *pointPtr,		/* Array of points describing polygon. All
+				 * points must be absolute
+				 * (CoordModeOrigin). */
+    int numPoints,		/* Number of points at *pointPtr. */
+    int borderWidth,		/* Width of border, measured in pixels to the
+				 * left of the polygon's trajectory. May be
+				 * negative. */
+    int leftRelief)		/* TK_RELIEF_RAISED or TK_RELIEF_SUNKEN:
+				 * indicates how stuff to left of trajectory
+				 * looks relative to stuff on right. */
 {
     XPoint poly[4], b1, b2, newB1, newB2;
     XPoint perp, c, shift1, shift2;	/* Used for handling parallel lines. */
@@ -796,8 +782,8 @@ Tk_Draw3DPolygon(tkwin, drawable, border, pointPtr, numPoints,
     }
 
     /*
-     * If the polygon is already closed, drop the last point from it
-     * (we'll close it automatically).
+     * If the polygon is already closed, drop the last point from it (we'll
+     * close it automatically).
      */
 
     p1Ptr = &pointPtr[numPoints-1];
@@ -807,8 +793,8 @@ Tk_Draw3DPolygon(tkwin, drawable, border, pointPtr, numPoints,
     }
 
     /*
-     * The loop below is executed once for each vertex in the polgon.
-     * At the beginning of each iteration things look like this:
+     * The loop below is executed once for each vertex in the polgon. At the
+     * beginning of each iteration things look like this:
      *
      *          poly[1]       /
      *             *        /
@@ -826,23 +812,21 @@ Tk_Draw3DPolygon(tkwin, drawable, border, pointPtr, numPoints,
      *             x-------------------------
      *
      * The job of this iteration is to do the following:
-     * (a) Compute x (the border corner corresponding to
-     *     pointPtr[i]) and put it in poly[2].  As part of
-     *	   this, compute a new b1 and b2 value for the next
-     *	   side of the polygon.
+     * (a) Compute x (the border corner corresponding to pointPtr[i]) and put
+     *	   it in poly[2]. As part of this, compute a new b1 and b2 value for
+     *	   the next side of the polygon.
      * (b) Put pointPtr[i] into poly[3].
      * (c) Draw the polygon given by poly[0..3].
-     * (d) Advance poly[0], poly[1], b1, and b2 for the
-     *     next side of the polygon.
+     * (d) Advance poly[0], poly[1], b1, and b2 for the next side of the
+     *     polygon.
      */
 
     /*
-     * The above situation doesn't first come into existence until
-     * two points have been processed;  the first two points are
-     * used to "prime the pump", so some parts of the processing
-     * are ommitted for these points.  The variable "pointsSeen"
-     * keeps track of the priming process;  it has to be separate
-     * from i in order to be able to ignore duplicate points in the
+     * The above situation doesn't first come into existence until two points
+     * have been processed; the first two points are used to "prime the pump",
+     * so some parts of the processing are ommitted for these points. The
+     * variable "pointsSeen" keeps track of the priming process; it has to be
+     * separate from i in order to be able to ignore duplicate points in the
      * polygon.
      */
 
@@ -854,9 +838,10 @@ Tk_Draw3DPolygon(tkwin, drawable, border, pointPtr, numPoints,
 	}
 	if ((p2Ptr->x == p1Ptr->x) && (p2Ptr->y == p1Ptr->y)) {
 	    /*
-	     * Ignore duplicate points (they'd cause core dumps in
-	     * ShiftLine calls below).
+	     * Ignore duplicate points (they'd cause core dumps in ShiftLine
+	     * calls below).
 	     */
+
 	    continue;
 	}
 	ShiftLine(p1Ptr, p2Ptr, borderWidth, &newB1);
@@ -868,9 +853,8 @@ Tk_Draw3DPolygon(tkwin, drawable, border, pointPtr, numPoints,
 	    parallel = Intersect(&newB1, &newB2, &b1, &b2, &poly[2]);
 
 	    /*
-	     * If two consecutive segments of the polygon are parallel,
-	     * then things get more complex.  Consider the following
-	     * diagram:
+	     * If two consecutive segments of the polygon are parallel, then
+	     * things get more complex. Consider the following diagram:
 	     *
 	     * poly[1]
 	     *    *----b1-----------b2------a
@@ -882,16 +866,16 @@ Tk_Draw3DPolygon(tkwin, drawable, border, pointPtr, numPoints,
 	     *              --*--------*----c
 	     *              newB1    newB2
 	     *
-	     * Instead of using x and *p1Ptr for poly[2] and poly[3], as
-	     * in the original diagram, use a and b as above.  Then instead
-	     * of using x and *p1Ptr for the new poly[0] and poly[1], use
-	     * b and c as above.
+	     * Instead of using x and *p1Ptr for poly[2] and poly[3], as in
+	     * the original diagram, use a and b as above. Then instead of
+	     * using x and *p1Ptr for the new poly[0] and poly[1], use b and c
+	     * as above.
 	     *
 	     * Do the computation in three stages:
-	     * 1. Compute a point "perp" such that the line p1Ptr-perp
-	     *    is perpendicular to p1Ptr-p2Ptr.
-	     * 2. Compute the points a and c by intersecting the lines
-	     *    b1-b2 and newB1-newB2 with p1Ptr-perp.
+	     * 1. Compute a point "perp" such that the line p1Ptr-perp is
+	     *    perpendicular to p1Ptr-p2Ptr.
+	     * 2. Compute the points a and c by intersecting the lines b1-b2
+	     *    and newB1-newB2 with p1Ptr-perp.
 	     * 3. Compute b by shifting p1Ptr-perp to the right and
 	     *    intersecting it with p1Ptr-p2Ptr.
 	     */
@@ -957,33 +941,34 @@ Tk_Draw3DPolygon(tkwin, drawable, border, pointPtr, numPoints,
  */
 
 void
-Tk_Fill3DRectangle(tkwin, drawable, border, x, y, width,
-	height, borderWidth, relief)
-    Tk_Window tkwin;		/* Window for which border was allocated. */
-    Drawable drawable;		/* X window or pixmap in which to draw. */
-    Tk_3DBorder border;		/* Token for border to draw. */
-    int x, y, width, height;	/* Outside area of rectangular region. */
-    int borderWidth;		/* Desired width for border, in
-				 * pixels. Border will be *inside* region. */
-    int relief;			/* Indicates 3D effect: TK_RELIEF_FLAT,
+Tk_Fill3DRectangle(
+    Tk_Window tkwin,		/* Window for which border was allocated. */
+    Drawable drawable,		/* X window or pixmap in which to draw. */
+    Tk_3DBorder border,		/* Token for border to draw. */
+    int x, int y, int width, int height,
+				/* Outside area of rectangular region. */
+    int borderWidth,		/* Desired width for border, in pixels. Border
+				 * will be *inside* region. */
+    int relief)			/* Indicates 3D effect: TK_RELIEF_FLAT,
 				 * TK_RELIEF_RAISED, or TK_RELIEF_SUNKEN. */
 {
     register TkBorder *borderPtr = (TkBorder *) border;
     int doubleBorder;
 
     /*
-     * This code is slightly tricky because it only draws the background
-     * in areas not covered by the 3D border. This avoids flashing
-     * effects on the screen for the border region.
+     * This code is slightly tricky because it only draws the background in
+     * areas not covered by the 3D border. This avoids flashing effects on the
+     * screen for the border region.
      */
-  
+
     if (relief == TK_RELIEF_FLAT) {
 	borderWidth = 0;
     } else {
 	/*
-	 * We need to make this extra check, otherwise we will leave
-	 * garbage in thin frames [Bug: 3596]
+	 * We need to make this extra check, otherwise we will leave garbage
+	 * in thin frames [Bug: 3596]
 	 */
+
 	if (width < 2*borderWidth) {
 	    borderWidth = width/2;
 	}
@@ -1022,22 +1007,21 @@ Tk_Fill3DRectangle(tkwin, drawable, border, x, y, width,
  */
 
 void
-Tk_Fill3DPolygon(tkwin, drawable, border, pointPtr, numPoints,
-	borderWidth, leftRelief)
-    Tk_Window tkwin;		/* Window for which border was allocated. */
-    Drawable drawable;		/* X window or pixmap in which to draw. */
-    Tk_3DBorder border;		/* Token for border to draw. */
-    XPoint *pointPtr;		/* Array of points describing
-				 * polygon.  All points must be
-				 * absolute (CoordModeOrigin). */
-    int numPoints;		/* Number of points at *pointPtr. */
-    int borderWidth;		/* Width of border, measured in
-				 * pixels to the left of the polygon's
-				 * trajectory.   May be negative. */
-    int leftRelief;			/* Indicates 3D effect of left side of
+Tk_Fill3DPolygon(
+    Tk_Window tkwin,		/* Window for which border was allocated. */
+    Drawable drawable,		/* X window or pixmap in which to draw. */
+    Tk_3DBorder border,		/* Token for border to draw. */
+    XPoint *pointPtr,		/* Array of points describing polygon. All
+				 * points must be absolute
+				 * (CoordModeOrigin). */
+    int numPoints,		/* Number of points at *pointPtr. */
+    int borderWidth,		/* Width of border, measured in pixels to the
+				 * left of the polygon's trajectory. May be
+				 * negative. */
+    int leftRelief)		/* Indicates 3D effect of left side of
 				 * trajectory relative to right:
-				 * TK_RELIEF_FLAT, TK_RELIEF_RAISED,
-				 * or TK_RELIEF_SUNKEN. */
+				 * TK_RELIEF_FLAT, TK_RELIEF_RAISED, or
+				 * TK_RELIEF_SUNKEN. */
 {
     register TkBorder *borderPtr = (TkBorder *) border;
 
@@ -1066,8 +1050,8 @@ Tk_Fill3DPolygon(tkwin, drawable, border, pointPtr, numPoints,
  */
 
 static void
-BorderInit(dispPtr)
-     TkDisplay * dispPtr;     /* Used to access thread-specific data. */
+BorderInit(
+     TkDisplay *dispPtr)	/* Used to access thread-specific data. */
 {
     dispPtr->borderInit = 1;
     Tcl_InitHashTable(&dispPtr->borderTable, TCL_STRING_KEYS);
@@ -1078,9 +1062,8 @@ BorderInit(dispPtr)
  *
  * ShiftLine --
  *
- *	Given two points on a line, compute a point on a
- *	new line that is parallel to the given line and
- *	a given distance away from it.
+ *	Given two points on a line, compute a point on a new line that is
+ *	parallel to the given line and a given distance away from it.
  *
  * Results:
  *	None.
@@ -1092,36 +1075,31 @@ BorderInit(dispPtr)
  */
 
 static void
-ShiftLine(p1Ptr, p2Ptr, distance, p3Ptr)
-    XPoint *p1Ptr;		/* First point on line. */
-    XPoint *p2Ptr;		/* Second point on line. */
-    int distance;		/* New line is to be this many
-				 * units to the left of original
-				 * line, when looking from p1 to
-				 * p2.  May be negative. */
-    XPoint *p3Ptr;		/* Store coords of point on new
-				 * line here. */
+ShiftLine(
+    XPoint *p1Ptr,		/* First point on line. */
+    XPoint *p2Ptr,		/* Second point on line. */
+    int distance,		/* New line is to be this many units to the
+				 * left of original line, when looking from p1
+				 * to p2. May be negative. */
+    XPoint *p3Ptr)		/* Store coords of point on new line here. */
 {
     int dx, dy, dxNeg, dyNeg;
 
     /*
-     * The table below is used for a quick approximation in
-     * computing the new point.  An index into the table
-     * is 128 times the slope of the original line (the slope
-     * must always be between 0 and 1).  The value of the table
-     * entry is 128 times the amount to displace the new line
-     * in y for each unit of perpendicular distance.  In other
-     * words, the table maps from the tangent of an angle to
-     * the inverse of its cosine.  If the slope of the original
-     * line is greater than 1, then the displacement is done in
-     * x rather than in y.
+     * The table below is used for a quick approximation in computing the new
+     * point. An index into the table is 128 times the slope of the original
+     * line (the slope must always be between 0 and 1). The value of the table
+     * entry is 128 times the amount to displace the new line in y for each
+     * unit of perpendicular distance. In other words, the table maps from the
+     * tangent of an angle to the inverse of its cosine. If the slope of the
+     * original line is greater than 1, then the displacement is done in x
+     * rather than in y.
      */
 
     static int shiftTable[129];
 
     /*
-     * Initialize the table if this is the first time it is
-     * used.
+     * Initialize the table if this is the first time it is used.
      */
 
     if (shiftTable[0] == 0) {
@@ -1173,10 +1151,9 @@ ShiftLine(p1Ptr, p2Ptr, distance, p3Ptr)
  *	Find the intersection point between two lines.
  *
  * Results:
- *	Under normal conditions 0 is returned and the point
- *	at *iPtr is filled in with the intersection between
- *	the two lines.  If the two lines are parallel, then
- *	-1 is returned and *iPtr isn't modified.
+ *	Under normal conditions 0 is returned and the point at *iPtr is filled
+ *	in with the intersection between the two lines. If the two lines are
+ *	parallel, then -1 is returned and *iPtr isn't modified.
  *
  * Side effects:
  *	None.
@@ -1185,19 +1162,19 @@ ShiftLine(p1Ptr, p2Ptr, distance, p3Ptr)
  */
 
 static int
-Intersect(a1Ptr, a2Ptr, b1Ptr, b2Ptr, iPtr)
-    XPoint *a1Ptr;		/* First point of first line. */
-    XPoint *a2Ptr;		/* Second point of first line. */
-    XPoint *b1Ptr;		/* First point of second line. */
-    XPoint *b2Ptr;		/* Second point of second line. */
-    XPoint *iPtr;		/* Filled in with intersection point. */
+Intersect(
+    XPoint *a1Ptr,		/* First point of first line. */
+    XPoint *a2Ptr,		/* Second point of first line. */
+    XPoint *b1Ptr,		/* First point of second line. */
+    XPoint *b2Ptr,		/* Second point of second line. */
+    XPoint *iPtr)		/* Filled in with intersection point. */
 {
     int dxadyb, dxbdya, dxadxb, dyadyb, p, q;
 
     /*
-     * The code below is just a straightforward manipulation of two
-     * equations of the form y = (x-x1)*(y2-y1)/(x2-x1) + y1 to solve
-     * for the x-coordinate of intersection, then the y-coordinate.
+     * The code below is just a straightforward manipulation of two equations
+     * of the form y = (x-x1)*(y2-y1)/(x2-x1) + y1 to solve for the
+     * x-coordinate of intersection, then the y-coordinate.
      */
 
     dxadyb = (a2Ptr->x - a1Ptr->x)*(b2Ptr->y - b1Ptr->y);
@@ -1238,26 +1215,26 @@ Intersect(a1Ptr, a2Ptr, b1Ptr, b2Ptr, iPtr)
  *
  * Tk_Get3DBorderFromObj --
  *
- *	Returns the border referred to by a Tcl object.  The border must
- *	already have been allocated via a call to Tk_Alloc3DBorderFromObj 
- *	or Tk_Get3DBorder.
+ *	Returns the border referred to by a Tcl object. The border must
+ *	already have been allocated via a call to Tk_Alloc3DBorderFromObj or
+ *	Tk_Get3DBorder.
  *
  * Results:
- *	Returns the Tk_3DBorder that matches the tkwin and the string rep
- *	of the name of the border given in objPtr.
+ *	Returns the Tk_3DBorder that matches the tkwin and the string rep of
+ *	the name of the border given in objPtr.
  *
  * Side effects:
- *	If the object is not already a border, the conversion will free
- *	any old internal representation. 
+ *	If the object is not already a border, the conversion will free any
+ *	old internal representation.
  *
  *----------------------------------------------------------------------
  */
 
 Tk_3DBorder
-Tk_Get3DBorderFromObj(tkwin, objPtr)
-    Tk_Window tkwin;
-    Tcl_Obj *objPtr;		/* The object whose string value selects
-				 * a border. */
+Tk_Get3DBorderFromObj(
+    Tk_Window tkwin,
+    Tcl_Obj *objPtr)		/* The object whose string value selects a
+				 * border. */
 {
     TkBorder *borderPtr = NULL;
     Tcl_HashEntry *hashPtr;
@@ -1268,10 +1245,9 @@ Tk_Get3DBorderFromObj(tkwin, objPtr)
     }
 
     /*
-     * If we are lucky (and the user doesn't use too many different
-     * displays, screens, or colormaps...) then the  TkBorder 
-     * structure we need will be cached in the internal
-     * representation of the Tcl_Obj.  Check it out...
+     * If we are lucky (and the user doesn't use too many different displays,
+     * screens, or colormaps...) then the TkBorder structure we need will be
+     * cached in the internal representation of the Tcl_Obj. Check it out...
      */
 
     borderPtr = (TkBorder *) objPtr->internalRep.twoPtrValue.ptr1;
@@ -1280,22 +1256,22 @@ Tk_Get3DBorderFromObj(tkwin, objPtr)
 	    && (Tk_Screen(tkwin) == borderPtr->screen)
 	    && (Tk_Colormap(tkwin) == borderPtr->colormap)) {
 	/*
-	 * The object already points to the right border structure.
-	 * Just return it.
+	 * The object already points to the right border structure. Just
+	 * return it.
 	 */
+
 	return (Tk_3DBorder) borderPtr;
     }
 
     /*
-     * If we make it here, it means we aren't so lucky.  Either there
-     * was no cached TkBorder in the Tcl_Obj, or the TkBorder that was
-     * there is for the wrong screen/colormap.  Either way, we have
-     * to search for the right TkBorder.  For each color name, there is
-     * linked list of TkBorder structures, one structure for each 
-     * screen/colormap combination.  The head of the linked list is
-     * recorded in a hash table (where the key is the color name)
-     * attached to the TkDisplay structure.  Walk this list to find
-     * the right TkBorder structure.
+     * If we make it here, it means we aren't so lucky. Either there was no
+     * cached TkBorder in the Tcl_Obj, or the TkBorder that was there is for
+     * the wrong screen/colormap. Either way, we have to search for the right
+     * TkBorder. For each color name, there is linked list of TkBorder
+     * structures, one structure for each screen/colormap combination. The
+     * head of the linked list is recorded in a hash table (where the key is
+     * the color name) attached to the TkDisplay structure. Walk this list to
+     * find the right TkBorder structure.
      */
 
     hashPtr = Tcl_FindHashEntry(&dispPtr->borderTable, Tcl_GetString(objPtr));
@@ -1307,13 +1283,13 @@ Tk_Get3DBorderFromObj(tkwin, objPtr)
 	if ((Tk_Screen(tkwin) == borderPtr->screen)
 		&& (Tk_Colormap(tkwin) == borderPtr->colormap)) {
 	    FreeBorderObjProc(objPtr);
-	    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) borderPtr;
+	    objPtr->internalRep.twoPtrValue.ptr1 = (void *) borderPtr;
 	    borderPtr->objRefCount++;
 	    return (Tk_3DBorder) borderPtr;
 	}
     }
 
-    error:
+  error:
     Tcl_Panic("Tk_Get3DBorderFromObj called with non-existent border!");
     /*
      * The following code isn't reached; it's just there to please compilers.
@@ -1335,20 +1311,20 @@ Tk_Get3DBorderFromObj(tkwin, objPtr)
  *	unless "interp" is NULL.
  *
  * Side effects:
- *	If no error occurs, a blank internal format for a border value
- *	is intialized. The final form cannot be done without a Tk_Window.
+ *	If no error occurs, a blank internal format for a border value is
+ *	intialized. The final form cannot be done without a Tk_Window.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-InitBorderObj(objPtr)
-    Tcl_Obj *objPtr;		/* The object to convert. */
+InitBorderObj(
+    Tcl_Obj *objPtr)		/* The object to convert. */
 {
     Tcl_ObjType *typePtr;
 
     /*
-     * Free the old internalRep before setting the new one. 
+     * Free the old internalRep before setting the new one.
      */
 
     Tcl_GetString(objPtr);
@@ -1357,7 +1333,7 @@ InitBorderObj(objPtr)
 	(*typePtr->freeIntRepProc)(objPtr);
     }
     objPtr->typePtr = &tkBorderObjType;
-    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) NULL;
+    objPtr->internalRep.twoPtrValue.ptr1 = NULL;
 }
 
 /*
@@ -1365,13 +1341,13 @@ InitBorderObj(objPtr)
  *
  * TkDebugBorder --
  *
- *	This procedure returns debugging information about a border.
+ *	This function returns debugging information about a border.
  *
  * Results:
  *	The return value is a list with one sublist for each TkBorder
- *	corresponding to "name".  Each sublist has two elements that
- *	contain the resourceRefCount and objRefCount fields from the
- *	TkBorder structure.
+ *	corresponding to "name". Each sublist has two elements that contain
+ *	the resourceRefCount and objRefCount fields from the TkBorder
+ *	structure.
  *
  * Side effects:
  *	None.
@@ -1380,10 +1356,10 @@ InitBorderObj(objPtr)
  */
 
 Tcl_Obj *
-TkDebugBorder(tkwin, name)
-    Tk_Window tkwin;		/* The window in which the border will be
-				 * used (not currently used). */
-    char *name;			/* Name of the desired color. */
+TkDebugBorder(
+    Tk_Window tkwin,		/* The window in which the border will be used
+				 * (not currently used). */
+    char *name)			/* Name of the desired color. */
 {
     TkBorder *borderPtr;
     Tcl_HashEntry *hashPtr;
@@ -1402,9 +1378,17 @@ TkDebugBorder(tkwin, name)
 	    Tcl_ListObjAppendElement(NULL, objPtr,
 		    Tcl_NewIntObj(borderPtr->resourceRefCount));
 	    Tcl_ListObjAppendElement(NULL, objPtr,
-		    Tcl_NewIntObj(borderPtr->objRefCount)); 
+		    Tcl_NewIntObj(borderPtr->objRefCount));
 	    Tcl_ListObjAppendElement(NULL, resultPtr, objPtr);
 	}
     }
     return resultPtr;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */