ANSIfy

10 files changed, 1981 insertions, 2019 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:
+ */
diff --git a/generic/tkArgv.c b/generic/tkArgv.c
index a0c8143..c1eb479 100644
--- a/generic/tkArgv.c
+++ b/generic/tkArgv.c
@@ -1,87 +1,84 @@
 /*
  * tkArgv.c --
  *
- *	This file contains a procedure that handles table-based
- *	argv-argc parsing.
+ *	This file contains a function that handles table-based argv-argc
+ *	parsing.
  *
  * 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: tkArgv.c,v 1.4 2002/01/25 21:09:36 dgp Exp $
+ * RCS: @(#) $Id: tkArgv.c,v 1.5 2005/11/04 11:52:50 dkf Exp $
  */
 
 #include "tkPort.h"
 #include "tk.h"
 
 /*
- * Default table of argument descriptors.  These are normally available
- * in every application.
+ * Default table of argument descriptors. These are normally available in
+ * every application.
  */
 
 static Tk_ArgvInfo defaultTable[] = {
-    {"-help",	TK_ARGV_HELP,	(char *) NULL,	(char *) NULL,
+    {"-help",	TK_ARGV_HELP, NULL, NULL,
 	"Print summary of command-line options and abort"},
-    {NULL,	TK_ARGV_END,	(char *) NULL,	(char *) NULL,
-	(char *) NULL}
+    {NULL,	TK_ARGV_END, NULL, NULL, NULL}
 };
 
 /*
- * Forward declarations for procedures defined in this file:
+ * Forward declarations for functions defined in this file:
  */
 
-static void	PrintUsage _ANSI_ARGS_((Tcl_Interp *interp,
-		    Tk_ArgvInfo *argTable, int flags));
+static void	PrintUsage(Tcl_Interp *interp, Tk_ArgvInfo *argTable,
+		    int flags);
 
 /*
  *----------------------------------------------------------------------
  *
  * Tk_ParseArgv --
  *
- *	Process an argv array according to a table of expected
- *	command-line options.  See the manual page for more details.
+ *	Process an argv array according to a table of expected command-line
+ *	options. See the manual page for more details.
  *
  * Results:
- *	The return value is a standard Tcl return value.  If an
- *	error occurs then an error message is left in the interp's result.
- *	Under normal conditions, both *argcPtr and *argv are modified
- *	to return the arguments that couldn't be processed here (they
- *	didn't match the option table, or followed an TK_ARGV_REST
- *	argument).
+ *	The return value is a standard Tcl return value. If an error occurs
+ *	then an error message is left in the interp's result. Under normal
+ *	conditions, both *argcPtr and *argv are modified to return the
+ *	arguments that couldn't be processed here (they didn't match the
+ *	option table, or followed an TK_ARGV_REST argument).
  *
  * Side effects:
- *	Variables may be modified, resources may be entered for tkwin,
- *	or procedures may be called.  It all depends on the arguments
- *	and their entries in argTable.  See the user documentation
- *	for details.
+ *	Variables may be modified, resources may be entered for tkwin, or
+ *	functions may be called. It all depends on the arguments and their
+ *	entries in argTable. See the user documentation for details.
  *
  *----------------------------------------------------------------------
  */
 
 int
-Tk_ParseArgv(interp, tkwin, argcPtr, argv, argTable, flags)
-    Tcl_Interp *interp;		/* Place to store error message. */
-    Tk_Window tkwin;		/* Window to use for setting Tk options.
-				 * NULL means ignore Tk option specs. */
-    int *argcPtr;		/* Number of arguments in argv.  Modified
-				 * to hold # args left in argv at end. */
-    CONST char **argv;		/* Array of arguments.  Modified to hold
-				 * those that couldn't be processed here. */
-    Tk_ArgvInfo *argTable;	/* Array of option descriptions */
-    int flags;			/* Or'ed combination of various flag bits,
+Tk_ParseArgv(
+    Tcl_Interp *interp,		/* Place to store error message. */
+    Tk_Window tkwin,		/* Window to use for setting Tk options. NULL
+				 * means ignore Tk option specs. */
+    int *argcPtr,		/* Number of arguments in argv. Modified to
+				 * hold # args left in argv at end. */
+    CONST char **argv,		/* Array of arguments. Modified to hold those
+				 * that couldn't be processed here. */
+    Tk_ArgvInfo *argTable,	/* Array of option descriptions */
+    int flags)			/* Or'ed combination of various flag bits,
 				 * such as TK_ARGV_NO_DEFAULTS. */
 {
     register Tk_ArgvInfo *infoPtr;
-				/* Pointer to the current entry in the
-				 * table of argument descriptions. */
+				/* Pointer to the current entry in the table
+				 * of argument descriptions. */
     Tk_ArgvInfo *matchPtr;	/* Descriptor that matches current argument. */
     CONST char *curArg;		/* Current argument */
     register char c;		/* Second character of current arg (used for
-				 * quick check for matching;  use 2nd char.
-				 * because first char. will almost always
-				 * be '-'). */
+				 * quick check for matching; use 2nd char.
+				 * because first char. will almost always be
+				 * '-'). */
     int srcIndex;		/* Location from which to read next argument
 				 * from argv. */
     int dstIndex;		/* Index into argv to which next unused
@@ -111,9 +108,8 @@ Tk_ParseArgv(interp, tkwin, argcPtr, argv, argTable, flags)
 	}
 
 	/*
-	 * Loop throught the argument descriptors searching for one with
-	 * the matching key string.  If found, leave a pointer to it in
-	 * matchPtr.
+	 * Loop throught the argument descriptors searching for one with the
+	 * matching key string. If found, leave a pointer to it in matchPtr.
 	 */
 
 	matchPtr = NULL;
@@ -147,7 +143,7 @@ Tk_ParseArgv(interp, tkwin, argcPtr, argv, argTable, flags)
 		 }
 		 if (matchPtr != NULL) {
 		     Tcl_AppendResult(interp, "ambiguous option \"", curArg,
-			     "\"", (char *) NULL);
+			     "\"", NULL);
 		     return TCL_ERROR;
 		 }
 		 matchPtr = infoPtr;
@@ -156,13 +152,13 @@ Tk_ParseArgv(interp, tkwin, argcPtr, argv, argTable, flags)
 	if (matchPtr == NULL) {
 
 	    /*
-	     * Unrecognized argument.  Just copy it down, unless the caller
+	     * Unrecognized argument. Just copy it down, unless the caller
 	     * prefers an error to be registered.
 	     */
 
 	    if (flags & TK_ARGV_NO_LEFTOVERS) {
 		Tcl_AppendResult(interp, "unrecognized argument \"",
-			curArg, "\"", (char *) NULL);
+			curArg, "\"", NULL);
 		return TCL_ERROR;
 	    }
 	    argv[dstIndex] = curArg;
@@ -174,154 +170,147 @@ Tk_ParseArgv(interp, tkwin, argcPtr, argv, argTable, flags)
 	 * Take the appropriate action based on the option type
 	 */
 
-	gotMatch:
+    gotMatch:
 	infoPtr = matchPtr;
 	switch (infoPtr->type) {
-	    case TK_ARGV_CONSTANT:
-		*((int *) infoPtr->dst) = (int) infoPtr->src;
-		break;
-	    case TK_ARGV_INT:
-		if (argc == 0) {
-		    goto missingArg;
-		} else {
-		    char *endPtr;
-
-		    *((int *) infoPtr->dst) =
-			    strtol(argv[srcIndex], &endPtr, 0);
-		    if ((endPtr == argv[srcIndex]) || (*endPtr != 0)) {
-			Tcl_AppendResult(interp, "expected integer argument ",
-				"for \"", infoPtr->key, "\" but got \"",
-				argv[srcIndex], "\"", (char *) NULL);
-			return TCL_ERROR;
-		    }
-		    srcIndex++;
-		    argc--;
-		}
-		break;
-	    case TK_ARGV_STRING:
-		if (argc == 0) {
-		    goto missingArg;
-		} else {
-		    *((CONST char **)infoPtr->dst) = argv[srcIndex];
-		    srcIndex++;
-		    argc--;
-		}
-		break;
-	    case TK_ARGV_UID:
-		if (argc == 0) {
-		    goto missingArg;
-		} else {
-		    *((Tk_Uid *)infoPtr->dst) = Tk_GetUid(argv[srcIndex]);
-		    srcIndex++;
-		    argc--;
-		}
-		break;
-	    case TK_ARGV_REST:
-		*((int *) infoPtr->dst) = dstIndex;
-		goto argsDone;
-	    case TK_ARGV_FLOAT:
-		if (argc == 0) {
-		    goto missingArg;
-		} else {
-		    char *endPtr;
-
-		    *((double *) infoPtr->dst) =
-			    strtod(argv[srcIndex], &endPtr);
-		    if ((endPtr == argv[srcIndex]) || (*endPtr != 0)) {
-			Tcl_AppendResult(interp, "expected floating-point ",
-				"argument for \"", infoPtr->key,
-				"\" but got \"", argv[srcIndex], "\"",
-				(char *) NULL);
-			return TCL_ERROR;
-		    }
-		    srcIndex++;
-		    argc--;
-		}
-		break;
-	    case TK_ARGV_FUNC: {
-		typedef int (ArgvFunc) _ANSI_ARGS_ ((char *, char *,
-			CONST char *));
-		ArgvFunc *handlerProc;
-
-		handlerProc = (ArgvFunc *) infoPtr->src;
-		if ((*handlerProc)(infoPtr->dst, infoPtr->key,
-			argv[srcIndex])) {
-		    srcIndex += 1;
-		    argc -= 1;
-		}
-		break;
-	    }
-	    case TK_ARGV_GENFUNC: {
-		typedef int (ArgvGenFunc)_ANSI_ARGS_((char *, Tcl_Interp *, 
-			char *, int, CONST char **));
-		ArgvGenFunc *handlerProc;
+	case TK_ARGV_CONSTANT:
+	    *((int *) infoPtr->dst) = (int) infoPtr->src;
+	    break;
+	case TK_ARGV_INT:
+	    if (argc == 0) {
+		goto missingArg;
+	    } else {
+		char *endPtr;
 
-		handlerProc = (ArgvGenFunc *) infoPtr->src;
-		argc = (*handlerProc)(infoPtr->dst, interp, infoPtr->key,
-			argc, argv+srcIndex);
-		if (argc < 0) {
+		*((int *) infoPtr->dst) = strtol(argv[srcIndex], &endPtr, 0);
+		if ((endPtr == argv[srcIndex]) || (*endPtr != 0)) {
+		    Tcl_AppendResult(interp,"expected integer argument for \"",
+			    infoPtr->key, "\" but got \"", argv[srcIndex],"\"",
+			    NULL);
 		    return TCL_ERROR;
 		}
-		break;
+		srcIndex++;
+		argc--;
 	    }
-	    case TK_ARGV_HELP:
-		PrintUsage (interp, argTable, flags);
-		return TCL_ERROR;
-	    case TK_ARGV_CONST_OPTION:
-		Tk_AddOption(tkwin, infoPtr->dst, infoPtr->src,
-			TK_INTERACTIVE_PRIO);
-		break;
-	    case TK_ARGV_OPTION_VALUE:
-		if (argc < 1) {
-		    goto missingArg;
-		}
-		Tk_AddOption(tkwin, infoPtr->dst, argv[srcIndex],
-			TK_INTERACTIVE_PRIO);
+	    break;
+	case TK_ARGV_STRING:
+	    if (argc == 0) {
+		goto missingArg;
+	    } else {
+		*((CONST char **)infoPtr->dst) = argv[srcIndex];
 		srcIndex++;
 		argc--;
-		break;
-	    case TK_ARGV_OPTION_NAME_VALUE:
-		if (argc < 2) {
-		    Tcl_AppendResult(interp, "\"", curArg,
-			    "\" option requires two following arguments",
-			    (char *) NULL);
+	    }
+	    break;
+	case TK_ARGV_UID:
+	    if (argc == 0) {
+		goto missingArg;
+	    } else {
+		*((Tk_Uid *)infoPtr->dst) = Tk_GetUid(argv[srcIndex]);
+		srcIndex++;
+		argc--;
+	    }
+	    break;
+	case TK_ARGV_REST:
+	    *((int *) infoPtr->dst) = dstIndex;
+	    goto argsDone;
+	case TK_ARGV_FLOAT:
+	    if (argc == 0) {
+		goto missingArg;
+	    } else {
+		char *endPtr;
+
+		*((double *) infoPtr->dst) = strtod(argv[srcIndex], &endPtr);
+		if ((endPtr == argv[srcIndex]) || (*endPtr != 0)) {
+		    Tcl_AppendResult(interp, "expected floating-point ",
+			    "argument for \"", infoPtr->key, "\" but got \"",
+			    argv[srcIndex], "\"", NULL);
 		    return TCL_ERROR;
 		}
-		Tk_AddOption(tkwin, argv[srcIndex], argv[srcIndex+1],
-			TK_INTERACTIVE_PRIO);
-		srcIndex += 2;
-		argc -= 2;
-		break;
-	    default: {
-		char buf[64 + TCL_INTEGER_SPACE];
-		
-		sprintf(buf, "bad argument type %d in Tk_ArgvInfo",
-			infoPtr->type);
-		Tcl_SetResult(interp, buf, TCL_VOLATILE);
+		srcIndex++;
+		argc--;
+	    }
+	    break;
+	case TK_ARGV_FUNC: {
+	    typedef int (ArgvFunc)(char *, char *, CONST char *);
+	    ArgvFunc *handlerProc;
+
+	    handlerProc = (ArgvFunc *) infoPtr->src;
+	    if ((*handlerProc)(infoPtr->dst, infoPtr->key, argv[srcIndex])) {
+		srcIndex += 1;
+		argc -= 1;
+	    }
+	    break;
+	}
+	case TK_ARGV_GENFUNC: {
+	    typedef int (ArgvGenFunc)(char *, Tcl_Interp *, char *, int,
+		    CONST char **);
+	    ArgvGenFunc *handlerProc;
+
+	    handlerProc = (ArgvGenFunc *) infoPtr->src;
+	    argc = (*handlerProc)(infoPtr->dst, interp, infoPtr->key,
+		    argc, argv+srcIndex);
+	    if (argc < 0) {
 		return TCL_ERROR;
 	    }
+	    break;
+	}
+	case TK_ARGV_HELP:
+	    PrintUsage(interp, argTable, flags);
+	    return TCL_ERROR;
+	case TK_ARGV_CONST_OPTION:
+	    Tk_AddOption(tkwin, infoPtr->dst, infoPtr->src,
+		    TK_INTERACTIVE_PRIO);
+	    break;
+	case TK_ARGV_OPTION_VALUE:
+	    if (argc < 1) {
+		goto missingArg;
+	    }
+	    Tk_AddOption(tkwin, infoPtr->dst, argv[srcIndex],
+		    TK_INTERACTIVE_PRIO);
+	    srcIndex++;
+	    argc--;
+	    break;
+	case TK_ARGV_OPTION_NAME_VALUE:
+	    if (argc < 2) {
+		Tcl_AppendResult(interp, "\"", curArg,
+			"\" option requires two following arguments", NULL);
+		return TCL_ERROR;
+	    }
+	    Tk_AddOption(tkwin, argv[srcIndex], argv[srcIndex+1],
+		    TK_INTERACTIVE_PRIO);
+	    srcIndex += 2;
+	    argc -= 2;
+	    break;
+	default: {
+	    char buf[64 + TCL_INTEGER_SPACE];
+
+	    sprintf(buf, "bad argument type %d in Tk_ArgvInfo", infoPtr->type);
+	    Tcl_SetResult(interp, buf, TCL_VOLATILE);
+	    return TCL_ERROR;
+	}
 	}
     }
 
     /*
-     * If we broke out of the loop because of an OPT_REST argument,
-     * copy the remaining arguments down.
+     * If we broke out of the loop because of an OPT_REST argument, copy the
+     * remaining arguments down.
      */
 
-    argsDone:
+  argsDone:
     while (argc) {
 	argv[dstIndex] = argv[srcIndex];
 	srcIndex++;
 	dstIndex++;
 	argc--;
     }
-    argv[dstIndex] = (char *) NULL;
+    argv[dstIndex] = NULL;
     *argcPtr = dstIndex;
     return TCL_OK;
 
-    missingArg:
+  missingArg:
     Tcl_AppendResult(interp, "\"", curArg,
-	    "\" option requires an additional argument", (char *) NULL);
+	    "\" option requires an additional argument", NULL);
     return TCL_ERROR;
 }
 
@@ -333,10 +322,9 @@ Tk_ParseArgv(interp, tkwin, argcPtr, argv, argTable, flags)
  *	Generate a help string describing command-line options.
  *
  * Results:
- *	The interp's result will be modified to hold a help string
- *	describing all the options in argTable, plus all those
- *	in the default table unless TK_ARGV_NO_DEFAULTS is
- *	specified in flags.
+ *	The interp's result will be modified to hold a help string describing
+ *	all the options in argTable, plus all those in the default table
+ *	unless TK_ARGV_NO_DEFAULTS is specified in flags.
  *
  * Side effects:
  *	None.
@@ -345,14 +333,14 @@ Tk_ParseArgv(interp, tkwin, argcPtr, argv, argTable, flags)
  */
 
 static void
-PrintUsage(interp, argTable, flags)
-    Tcl_Interp *interp;		/* Place information in this interp's
-				 * result area. */
-    Tk_ArgvInfo *argTable;	/* Array of command-specific argument
+PrintUsage(
+    Tcl_Interp *interp,		/* Place information in this interp's result
+				 * area. */
+    Tk_ArgvInfo *argTable,	/* Array of command-specific argument
 				 * descriptions. */
-    int flags;			/* If the TK_ARGV_NO_DEFAULTS bit is set
-				 * in this word, then don't generate
-				 * information for default options. */
+    int flags)			/* If the TK_ARGV_NO_DEFAULTS bit is set in
+				 * this word, then don't generate information
+				 * for default options. */
 {
     register Tk_ArgvInfo *infoPtr;
     int width, i, numSpaces;
@@ -361,8 +349,8 @@ PrintUsage(interp, argTable, flags)
     char tmp[TCL_DOUBLE_SPACE];
 
     /*
-     * First, compute the width of the widest option key, so that we
-     * can make everything line up.
+     * First, compute the width of the widest option key, so that we can make
+     * everything line up.
      */
 
     width = 4;
@@ -380,59 +368,59 @@ PrintUsage(interp, argTable, flags)
 	}
     }
 
-    Tcl_AppendResult(interp, "Command-specific options:", (char *) NULL);
+    Tcl_AppendResult(interp, "Command-specific options:", NULL);
     for (i = 0; ; i++) {
 	for (infoPtr = i ? defaultTable : argTable;
 		infoPtr->type != TK_ARGV_END; infoPtr++) {
 	    if ((infoPtr->type == TK_ARGV_HELP) && (infoPtr->key == NULL)) {
-		Tcl_AppendResult(interp, "\n", infoPtr->help, (char *) NULL);
+		Tcl_AppendResult(interp, "\n", infoPtr->help, NULL);
 		continue;
 	    }
-	    Tcl_AppendResult(interp, "\n ", infoPtr->key, ":", (char *) NULL);
+	    Tcl_AppendResult(interp, "\n ", infoPtr->key, ":", NULL);
 	    numSpaces = width + 1 - strlen(infoPtr->key);
 	    while (numSpaces > 0) {
 		if (numSpaces >= NUM_SPACES) {
-		    Tcl_AppendResult(interp, spaces, (char *) NULL);
+		    Tcl_AppendResult(interp, spaces, NULL);
 		} else {
-		    Tcl_AppendResult(interp, spaces+NUM_SPACES-numSpaces,
-			    (char *) NULL);
+		    Tcl_AppendResult(interp, spaces+NUM_SPACES-numSpaces,NULL);
 		}
 		numSpaces -= NUM_SPACES;
 	    }
-	    Tcl_AppendResult(interp, infoPtr->help, (char *) NULL);
+	    Tcl_AppendResult(interp, infoPtr->help, NULL);
 	    switch (infoPtr->type) {
-		case TK_ARGV_INT: {
-		    sprintf(tmp, "%d", *((int *) infoPtr->dst));
-		    Tcl_AppendResult(interp, "\n\t\tDefault value: ",
-			    tmp, (char *) NULL);
-		    break;
-		}
-		case TK_ARGV_FLOAT: {
-		    sprintf(tmp, "%g", *((double *) infoPtr->dst));
-		    Tcl_AppendResult(interp, "\n\t\tDefault value: ",
-			    tmp, (char *) NULL);
-		    break;
-		}
-		case TK_ARGV_STRING: {
-		    char *string;
+	    case TK_ARGV_INT:
+		sprintf(tmp, "%d", *((int *) infoPtr->dst));
+		Tcl_AppendResult(interp, "\n\t\tDefault value: ", tmp, NULL);
+		break;
+	    case TK_ARGV_FLOAT:
+		sprintf(tmp, "%g", *((double *) infoPtr->dst));
+		Tcl_AppendResult(interp, "\n\t\tDefault value: ", tmp, NULL);
+		break;
+	    case TK_ARGV_STRING: {
+		char *string = *((char **) infoPtr->dst);
 
-		    string = *((char **) infoPtr->dst);
-		    if (string != NULL) {
-			Tcl_AppendResult(interp, "\n\t\tDefault value: \"",
-				string, "\"", (char *) NULL);
-		    }
-		    break;
-		}
-		default: {
-		    break;
+		if (string != NULL) {
+		    Tcl_AppendResult(interp, "\n\t\tDefault value: \"", string,
+			    "\"", NULL);
 		}
+		break;
+	    }
+	    default:
+		break;
 	    }
 	}
 
 	if ((flags & TK_ARGV_NO_DEFAULTS) || (i > 0)) {
 	    break;
 	}
-	Tcl_AppendResult(interp, "\nGeneric options for all commands:",
-		(char *) NULL);
+	Tcl_AppendResult(interp, "\nGeneric options for all commands:", NULL);
     }
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/generic/tkAtom.c b/generic/tkAtom.c
index 0137d40..eab269b 100644
--- a/generic/tkAtom.c
+++ b/generic/tkAtom.c
@@ -1,27 +1,26 @@
-/* 
+/*
  * tkAtom.c --
  *
- *	This file manages a cache of X Atoms in order to avoid
- *	interactions with the X server.  It's much like the Xmu
- *	routines, except it has a cleaner interface (caller
- *	doesn't have to provide permanent storage for atom names,
- *	for example).
+ *	This file manages a cache of X Atoms in order to avoid interactions
+ *	with the X server. It's much like the Xmu routines, except it has a
+ *	cleaner interface (caller doesn't have to provide permanent storage
+ *	for atom names, for example).
  *
  * Copyright (c) 1990-1994 The Regents of the University of California.
  * Copyright (c) 1994 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: tkAtom.c,v 1.3 2002/08/05 04:30:38 dgp Exp $
+ * RCS: @(#) $Id: tkAtom.c,v 1.4 2005/11/04 11:52:50 dkf Exp $
  */
 
 #include "tkPort.h"
 #include "tkInt.h"
 
 /*
- * The following are a list of the predefined atom strings.
- * They should match those found in xatom.h
+ * The following are a list of the predefined atom strings. They should match
+ * those found in xatom.h
  */
 
 static char * atomNameArray[] = {
@@ -48,24 +47,24 @@ static char * atomNameArray[] = {
     "COPYRIGHT",	"NOTICE",		"FONT_NAME",
     "FAMILY_NAME",	"FULL_NAME",		"CAP_HEIGHT",
     "WM_CLASS",		"WM_TRANSIENT_FOR",
-    (char *) NULL
+    NULL
 };
 
 /*
- * Forward references to procedures defined in this file:
+ * Forward references to functions defined in this file:
  */
 
-static void	AtomInit _ANSI_ARGS_((TkDisplay *dispPtr));
+static void	AtomInit(TkDisplay *dispPtr);
 
 /*
  *--------------------------------------------------------------
  *
  * Tk_InternAtom --
  *
- *	Given a string, produce the equivalent X atom.  This
- *	procedure is equivalent to XInternAtom, except that it
- *	keeps a local cache of atoms.  Once a name is known,
- *	the server need not be contacted again for that name.
+ *	Given a string, produce the equivalent X atom. This function is
+ *	equivalent to XInternAtom, except that it keeps a local cache of
+ *	atoms. Once a name is known, the server need not be contacted again
+ *	for that name.
  *
  * Results:
  *	The return value is the Atom corresponding to name.
@@ -77,10 +76,10 @@ static void	AtomInit _ANSI_ARGS_((TkDisplay *dispPtr));
  */
 
 Atom
-Tk_InternAtom(tkwin, name)
-    Tk_Window tkwin;		/* Window token;  map name to atom
-				 * for this window's display. */
-    CONST char *name;		/* Name to turn into atom. */
+Tk_InternAtom(
+    Tk_Window tkwin,		/* Window token; map name to atom for this
+				 * window's display. */
+    CONST char *name)		/* Name to turn into atom. */
 {
     register TkDisplay *dispPtr;
     register Tcl_HashEntry *hPtr;
@@ -98,8 +97,7 @@ Tk_InternAtom(tkwin, name)
 
 	atom = XInternAtom(dispPtr->display, name, False);
 	Tcl_SetHashValue(hPtr, atom);
-	hPtr2 = Tcl_CreateHashEntry(&dispPtr->atomTable, (char *) atom,
-		&new);
+	hPtr2 = Tcl_CreateHashEntry(&dispPtr->atomTable, (char *) atom, &new);
 	Tcl_SetHashValue(hPtr2, Tcl_GetHashKey(&dispPtr->nameTable, hPtr));
     }
     return (Atom) Tcl_GetHashValue(hPtr);
@@ -110,16 +108,15 @@ Tk_InternAtom(tkwin, name)
  *
  * Tk_GetAtomName --
  *
- *	This procedure is equivalent to XGetAtomName except that
- *	it uses the local atom cache to avoid contacting the
- *	server.
+ *	This function is equivalent to XGetAtomName except that it uses the
+ *	local atom cache to avoid contacting the server.
  *
  * Results:
- *	The return value is a character string corresponding to
- *	the atom given by "atom".  This string's storage space
- *	is static:  it need not be freed by the caller, and should
- *	not be modified by the caller.  If "atom" doesn't exist
- *	on tkwin's display, then the string "?bad atom?" is returned.
+ *	The return value is a character string corresponding to the atom given
+ *	by "atom". This string's storage space is static: it need not be freed
+ *	by the caller, and should not be modified by the caller. If "atom"
+ *	doesn't exist on tkwin's display, then the string "?bad atom?"  is
+ *	returned.
  *
  * Side effects:
  *	None.
@@ -128,11 +125,10 @@ Tk_InternAtom(tkwin, name)
  */
 
 CONST char *
-Tk_GetAtomName(tkwin, atom)
-    Tk_Window tkwin;		/* Window token;  map atom to name
-				 * relative to this window's
-				 * display. */
-    Atom atom;			/* Atom whose name is wanted. */
+Tk_GetAtomName(
+    Tk_Window tkwin,		/* Window token; map atom to name relative to
+				 * this window's display. */
+    Atom atom)			/* Atom whose name is wanted. */
 {
     register TkDisplay *dispPtr;
     register Tcl_HashEntry *hPtr;
@@ -148,8 +144,8 @@ Tk_GetAtomName(tkwin, atom)
 	Tk_ErrorHandler handler;
 	int new, mustFree;
 
-	handler= Tk_CreateErrorHandler(dispPtr->display, BadAtom,
-		-1, -1, (Tk_ErrorProc *) NULL, (ClientData) NULL);
+	handler = Tk_CreateErrorHandler(dispPtr->display, BadAtom, -1, -1,
+		NULL, (ClientData) NULL);
 	name = XGetAtomName(dispPtr->display, atom);
 	mustFree = 1;
 	if (name == NULL) {
@@ -157,15 +153,13 @@ Tk_GetAtomName(tkwin, atom)
 	    mustFree = 0;
 	}
 	Tk_DeleteErrorHandler(handler);
-	hPtr = Tcl_CreateHashEntry(&dispPtr->nameTable, (char *) name,
-		&new);
+	hPtr = Tcl_CreateHashEntry(&dispPtr->nameTable, name, &new);
 	Tcl_SetHashValue(hPtr, atom);
 	if (mustFree) {
 	    XFree(name);
 	}
 	name = Tcl_GetHashKey(&dispPtr->nameTable, hPtr);
-	hPtr = Tcl_CreateHashEntry(&dispPtr->atomTable, (char *) atom,
-		&new);
+	hPtr = Tcl_CreateHashEntry(&dispPtr->atomTable, (char *) atom, &new);
 	Tcl_SetHashValue(hPtr, name);
     }
     return Tcl_GetHashValue(hPtr);
@@ -188,8 +182,8 @@ Tk_GetAtomName(tkwin, atom)
  */
 
 static void
-AtomInit(dispPtr)
-    register TkDisplay *dispPtr;	/* Display to initialize. */
+AtomInit(
+    register TkDisplay *dispPtr)/* Display to initialize. */
 {
     Tcl_HashEntry *hPtr;
     Atom atom;
@@ -199,19 +193,27 @@ AtomInit(dispPtr)
     Tcl_InitHashTable(&dispPtr->atomTable, TCL_ONE_WORD_KEYS);
 
     for (atom = 1; atom <= XA_LAST_PREDEFINED; atom++) {
+	char *name;
+	int new;
+
 	hPtr = Tcl_FindHashEntry(&dispPtr->atomTable, (char *) atom);
-	if (hPtr == NULL) {
-	    char *name;
-	    int new;
-
-	    name = atomNameArray[atom - 1];
-	    hPtr = Tcl_CreateHashEntry(&dispPtr->nameTable, (char *) name,
-		&new);
-	    Tcl_SetHashValue(hPtr, atom);
-	    name = Tcl_GetHashKey(&dispPtr->nameTable, hPtr);
-	    hPtr = Tcl_CreateHashEntry(&dispPtr->atomTable, (char *) atom,
-		&new);
-	    Tcl_SetHashValue(hPtr, name);
+	if (hPtr != NULL) {
+	    continue;
 	}
+
+	name = atomNameArray[atom - 1];
+	hPtr = Tcl_CreateHashEntry(&dispPtr->nameTable, name, &new);
+	Tcl_SetHashValue(hPtr, atom);
+	name = Tcl_GetHashKey(&dispPtr->nameTable, hPtr);
+	hPtr = Tcl_CreateHashEntry(&dispPtr->atomTable, (char *) atom, &new);
+	Tcl_SetHashValue(hPtr, name);
     }
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/generic/tkBind.c b/generic/tkBind.c
index c6df007..235a0fa 100644
--- a/generic/tkBind.c
+++ b/generic/tkBind.c
@@ -11,7 +11,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- *  RCS: @(#) $Id: tkBind.c,v 1.36 2005/08/10 22:02:22 dkf Exp $
+ *  RCS: @(#) $Id: tkBind.c,v 1.37 2005/11/04 11:52:50 dkf Exp $
  */
 
 #include "tkPort.h"
@@ -363,7 +363,7 @@ static KeySymInfo keyArray[] = {
 #ifndef lint
 #include "ks_names.h"
 #endif
-    {(char *) NULL, 0}
+    {NULL, 0}
 };
 static Tcl_HashTable keySymTable; /* keyArray hashed by keysym value. */
 static Tcl_HashTable nameTable;	/* keyArray hashed by keysym name. */
@@ -500,7 +500,7 @@ static EventInfo eventArray[] = {
     {"Create",		CreateNotify,		SubstructureNotifyMask},
     {"MapRequest",	MapRequest,		SubstructureRedirectMask},
     {"ResizeRequest",	ResizeRequest,		ResizeRedirectMask},
-    {(char *) NULL,	0,			0}
+    {NULL,		0,			0}
 };
 static Tcl_HashTable eventTable;
 
@@ -721,8 +721,8 @@ static void		DoWarp(ClientData clientData);
  */
 
 void
-TkBindInit(mainPtr)
-    TkMainInfo *mainPtr;	/* The newly created application. */
+TkBindInit(
+    TkMainInfo *mainPtr)	/* The newly created application. */
 {
     BindInfo *bindInfoPtr;
 
@@ -805,8 +805,8 @@ TkBindInit(mainPtr)
  */
 
 void
-TkBindFree(mainPtr)
-    TkMainInfo *mainPtr;	/* The newly created application. */
+TkBindFree(
+    TkMainInfo *mainPtr)	/* The newly created application. */
 {
     BindInfo *bindInfoPtr;
 
@@ -838,8 +838,8 @@ TkBindFree(mainPtr)
  */
 
 Tk_BindingTable
-Tk_CreateBindingTable(interp)
-    Tcl_Interp *interp;		/* Interpreter to associate with the binding
+Tk_CreateBindingTable(
+    Tcl_Interp *interp)		/* Interpreter to associate with the binding
 				 * table: commands are executed in this
 				 * interpreter. */
 {
@@ -880,8 +880,8 @@ Tk_CreateBindingTable(interp)
  */
 
 void
-Tk_DeleteBindingTable(bindingTable)
-    Tk_BindingTable bindingTable;
+Tk_DeleteBindingTable(
+    Tk_BindingTable bindingTable)
 				/* Token for the binding table to destroy. */
 {
     BindingTable *bindPtr = (BindingTable *) bindingTable;
@@ -942,17 +942,17 @@ Tk_DeleteBindingTable(bindingTable)
  */
 
 unsigned long
-Tk_CreateBinding(interp, bindingTable, object, eventString, command, append)
-    Tcl_Interp *interp;		/* Used for error reporting. */
-    Tk_BindingTable bindingTable;
+Tk_CreateBinding(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    Tk_BindingTable bindingTable,
 				/* Table in which to create binding. */
-    ClientData object;		/* Token for object with which binding is
+    ClientData object,		/* Token for object with which binding is
 				 * associated. */
-    CONST char *eventString;	/* String describing event sequence that
+    CONST char *eventString,	/* String describing event sequence that
 				 * triggers binding. */
-    CONST char *command;	/* Contains Tcl command to execute when
+    CONST char *command,	/* Contains Tcl command to execute when
 				 * binding triggers. */
-    int append;			/* 0 means replace any existing binding for
+    int append)			/* 0 means replace any existing binding for
 				 * eventString; 1 means append to that
 				 * binding. If the existing binding is for a
 				 * callback function and not a Tcl command
@@ -1043,20 +1043,19 @@ Tk_CreateBinding(interp, bindingTable, object, eventString, command, append)
  */
 
 unsigned long
-TkCreateBindingProcedure(interp, bindingTable, object, eventString,
-	eventProc, freeProc, clientData)
-    Tcl_Interp *interp;		/* Used for error reporting. */
-    Tk_BindingTable bindingTable;
+TkCreateBindingProcedure(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    Tk_BindingTable bindingTable,
 				/* Table in which to create binding. */
-    ClientData object;		/* Token for object with which binding is
+    ClientData object,		/* Token for object with which binding is
 				 * associated. */
-    CONST char *eventString;	/* String describing event sequence that
+    CONST char *eventString,	/* String describing event sequence that
 				 * triggers binding. */
-    TkBindEvalProc *eventProc;	/* Function to invoke when binding triggers.
+    TkBindEvalProc *eventProc,	/* Function to invoke when binding triggers.
 				 * Must not be NULL. */
-    TkBindFreeProc *freeProc;	/* Function to invoke when binding is freed.
+    TkBindFreeProc *freeProc,	/* Function to invoke when binding is freed.
 				 * May be NULL for no function. */
-    ClientData clientData;	/* Arbitrary ClientData to pass to eventProc
+    ClientData clientData)	/* Arbitrary ClientData to pass to eventProc
 				 * and freeProc. */
 {
     BindingTable *bindPtr = (BindingTable *) bindingTable;
@@ -1122,13 +1121,13 @@ TkCreateBindingProcedure(interp, bindingTable, object, eventString,
  */
 
 int
-Tk_DeleteBinding(interp, bindingTable, object, eventString)
-    Tcl_Interp *interp;		/* Used for error reporting. */
-    Tk_BindingTable bindingTable;
+Tk_DeleteBinding(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    Tk_BindingTable bindingTable,
 				/* Table in which to delete binding. */
-    ClientData object;		/* Token for object with which binding is
+    ClientData object,		/* Token for object with which binding is
 				 * associated. */
-    CONST char *eventString;	/* String describing event sequence that
+    CONST char *eventString)	/* String describing event sequence that
 				 * triggers binding. */
 {
     BindingTable *bindPtr = (BindingTable *) bindingTable;
@@ -1217,13 +1216,13 @@ Tk_DeleteBinding(interp, bindingTable, object, eventString)
  */
 
 CONST char *
-Tk_GetBinding(interp, bindingTable, object, eventString)
-    Tcl_Interp *interp;		/* Interpreter for error reporting. */
-    Tk_BindingTable bindingTable;
+Tk_GetBinding(
+    Tcl_Interp *interp,		/* Interpreter for error reporting. */
+    Tk_BindingTable bindingTable,
 				/* Table in which to look for binding. */
-    ClientData object;		/* Token for object with which binding is
+    ClientData object,		/* Token for object with which binding is
 				 * associated. */
-    CONST char *eventString;	/* String describing event sequence that
+    CONST char *eventString)	/* String describing event sequence that
 				 * triggers binding. */
 {
     BindingTable *bindPtr = (BindingTable *) bindingTable;
@@ -1262,11 +1261,11 @@ Tk_GetBinding(interp, bindingTable, object, eventString)
  */
 
 void
-Tk_GetAllBindings(interp, bindingTable, object)
-    Tcl_Interp *interp;		/* Interpreter returning result or error. */
-    Tk_BindingTable bindingTable;
+Tk_GetAllBindings(
+    Tcl_Interp *interp,		/* Interpreter returning result or error. */
+    Tk_BindingTable bindingTable,
 				/* Table in which to look for bindings. */
-    ClientData object;		/* Token for object. */
+    ClientData object)		/* Token for object. */
 {
     BindingTable *bindPtr = (BindingTable *) bindingTable;
     PatSeq *psPtr;
@@ -1310,10 +1309,10 @@ Tk_GetAllBindings(interp, bindingTable, object)
  */
 
 void
-Tk_DeleteAllBindings(bindingTable, object)
-    Tk_BindingTable bindingTable;
+Tk_DeleteAllBindings(
+    Tk_BindingTable bindingTable,
 				/* Table in which to delete bindings. */
-    ClientData object;		/* Token for object. */
+    ClientData object)		/* Token for object. */
 {
     BindingTable *bindPtr = (BindingTable *) bindingTable;
     PatSeq *psPtr, *prevPtr;
@@ -1397,15 +1396,15 @@ Tk_DeleteAllBindings(bindingTable, object)
  */
 
 void
-Tk_BindEvent(bindingTable, eventPtr, tkwin, numObjects, objectPtr)
-    Tk_BindingTable bindingTable;
+Tk_BindEvent(
+    Tk_BindingTable bindingTable,
 				/* Table in which to look for bindings. */
-    XEvent *eventPtr;		/* What actually happened. */
-    Tk_Window tkwin;		/* Window on display where event occurred
+    XEvent *eventPtr,		/* What actually happened. */
+    Tk_Window tkwin,		/* Window on display where event occurred
 				 * (needed in order to locate display
 				 * information). */
-    int numObjects;		/* Number of objects at *objectPtr. */
-    ClientData *objectPtr;	/* Array of one or more objects to check for a
+    int numObjects,		/* Number of objects at *objectPtr. */
+    ClientData *objectPtr)	/* Array of one or more objects to check for a
 				 * matching binding. */
 {
     BindingTable *bindPtr;
@@ -1518,7 +1517,7 @@ Tk_BindEvent(bindingTable, eventPtr, tkwin, numObjects, objectPtr)
 	}
     }
     ringPtr = &bindPtr->eventRing[bindPtr->curEvent];
-    memcpy((VOID *) ringPtr, (VOID *) eventPtr, sizeof(XEvent));
+    memcpy((void *) ringPtr, (void *) eventPtr, sizeof(XEvent));
     detail.clientData = 0;
     flags = flagArray[ringPtr->type];
     if (flags & KEY) {
@@ -1650,7 +1649,7 @@ Tk_BindEvent(bindingTable, eventPtr, tkwin, numObjects, objectPtr)
 			    - sizeof(staticPending.matchArray)
 			    + matchSpace * sizeof(PatSeq*);
 		    new = (PendingBinding *) ckalloc(newSize);
-		    memcpy((VOID *) new, (VOID *) pendingPtr, oldSize);
+		    memcpy((void *) new, (void *) pendingPtr, oldSize);
 		    if (pendingPtr != &staticPending) {
 			ckfree((char *) pendingPtr);
 		    }
@@ -1866,8 +1865,8 @@ Tk_BindEvent(bindingTable, eventPtr, tkwin, numObjects, objectPtr)
  */
 
 void
-TkBindDeadWindow(winPtr)
-    TkWindow *winPtr;		/* The window that is being deleted. */
+TkBindDeadWindow(
+    TkWindow *winPtr)		/* The window that is being deleted. */
 {
     BindInfo *bindInfoPtr;
     PendingBinding *curPtr;
@@ -1928,22 +1927,22 @@ TkBindDeadWindow(winPtr)
  *----------------------------------------------------------------------
  */
 static PatSeq *
-MatchPatterns(dispPtr, bindPtr, psPtr, bestPtr, objectPtr, sourcePtrPtr)
-    TkDisplay *dispPtr;		/* Display from which the event came. */
-    BindingTable *bindPtr;	/* Information about binding table, such as
+MatchPatterns(
+    TkDisplay *dispPtr,		/* Display from which the event came. */
+    BindingTable *bindPtr,	/* Information about binding table, such as
 				 * ring of recent events. */
-    PatSeq *psPtr;		/* List of pattern sequences. */
-    PatSeq *bestPtr;		/* The best match seen so far, from a previous
+    PatSeq *psPtr,		/* List of pattern sequences. */
+    PatSeq *bestPtr,		/* The best match seen so far, from a previous
 				 * call to this function. NULL means no prior
 				 * best match. */
-    ClientData *objectPtr;	/* If NULL, the sequences at psPtr correspond
+    ClientData *objectPtr,	/* If NULL, the sequences at psPtr correspond
 				 * to "normal" bindings. If non-NULL, the
 				 * sequences at psPtr correspond to virtual
 				 * bindings; in order to match each sequence
 				 * must correspond to a virtual binding for
 				 * which a binding exists for object in
 				 * bindPtr. */
-    PatSeq **sourcePtrPtr;	/* Filled with the pattern sequence that
+    PatSeq **sourcePtrPtr)	/* Filled with the pattern sequence that
 				 * contains the eventProc and clientData
 				 * associated with the best match. If this
 				 * differs from the return value, it is the
@@ -2268,16 +2267,16 @@ MatchPatterns(dispPtr, bindPtr, psPtr, bestPtr, objectPtr, sourcePtrPtr)
  */
 
 static void
-ExpandPercents(winPtr, before, eventPtr, keySym, dsPtr)
-    TkWindow *winPtr;		/* Window where event occurred: needed to get
+ExpandPercents(
+    TkWindow *winPtr,		/* Window where event occurred: needed to get
 				 * input context. */
-    CONST char *before;		/* Command containing percent expressions to
+    CONST char *before,		/* Command containing percent expressions to
 				 * be replaced. */
-    XEvent *eventPtr;		/* X event containing information to be used
+    XEvent *eventPtr,		/* X event containing information to be used
 				 * in % replacements. */
-    KeySym keySym;		/* KeySym: only relevant for KeyPress and
+    KeySym keySym,		/* KeySym: only relevant for KeyPress and
 				 * KeyRelease events). */
-    Tcl_DString *dsPtr;		/* Dynamic string in which to append new
+    Tcl_DString *dsPtr)		/* Dynamic string in which to append new
 				 * command. */
 {
     int spaceNeeded, cvtFlags;	/* Used to substitute string as proper Tcl
@@ -2678,10 +2677,10 @@ ExpandPercents(winPtr, before, eventPtr, keySym, dsPtr)
  */
 
 static void
-ChangeScreen(interp, dispName, screenIndex)
-    Tcl_Interp *interp;		/* Interpreter in which to invoke command. */
-    char *dispName;		/* Name of new display. */
-    int screenIndex;		/* Index of new screen. */
+ChangeScreen(
+    Tcl_Interp *interp,		/* Interpreter in which to invoke command. */
+    char *dispName,		/* Name of new display. */
+    int screenIndex)		/* Index of new screen. */
 {
     Tcl_DString cmd;
     int code;
@@ -2699,7 +2698,6 @@ ChangeScreen(interp, dispName, screenIndex)
 	Tcl_BackgroundError(interp);
     }
 }
-
 
 /*
  *----------------------------------------------------------------------
@@ -2719,11 +2717,11 @@ ChangeScreen(interp, dispName, screenIndex)
  */
 
 int
-Tk_EventObjCmd(clientData, interp, objc, objv)
-    ClientData clientData;	/* Main window associated with interpreter. */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+Tk_EventObjCmd(
+    ClientData clientData,	/* Main window associated with interpreter. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     int index;
     Tk_Window tkwin;
@@ -2760,9 +2758,9 @@ Tk_EventObjCmd(clientData, interp, objc, objv)
 		    "virtual sequence ?sequence ...?");
 	    return TCL_ERROR;
 	}
-	name = Tcl_GetStringFromObj(objv[2], NULL);
+	name = Tcl_GetString(objv[2]);
 	for (i = 3; i < objc; i++) {
-	    event = Tcl_GetStringFromObj(objv[i], NULL);
+	    event = Tcl_GetString(objv[i]);
 	    if (CreateVirtualEvent(interp, vetPtr, name, event) != TCL_OK) {
 		return TCL_ERROR;
 	    }
@@ -2778,12 +2776,12 @@ Tk_EventObjCmd(clientData, interp, objc, objv)
 		    "virtual ?sequence sequence ...?");
 	    return TCL_ERROR;
 	}
-	name = Tcl_GetStringFromObj(objv[2], NULL);
+	name = Tcl_GetString(objv[2]);
 	if (objc == 3) {
 	    return DeleteVirtualEvent(interp, vetPtr, name, NULL);
 	}
 	for (i = 3; i < objc; i++) {
-	    event = Tcl_GetStringFromObj(objv[i], NULL);
+	    event = Tcl_GetString(objv[i]);
 	    if (DeleteVirtualEvent(interp, vetPtr, name, event) != TCL_OK) {
 		return TCL_ERROR;
 	    }
@@ -2828,8 +2826,8 @@ Tk_EventObjCmd(clientData, interp, objc, objv)
  */
 
 static void
-InitVirtualEventTable(vetPtr)
-    VirtualEventTable *vetPtr;	/* Pointer to virtual event table. Memory is
+InitVirtualEventTable(
+    VirtualEventTable *vetPtr)	/* Pointer to virtual event table. Memory is
 				 * supplied by the caller. */
 {
     Tcl_InitHashTable(&vetPtr->patternTable,
@@ -2855,8 +2853,8 @@ InitVirtualEventTable(vetPtr)
  */
 
 static void
-DeleteVirtualEventTable(vetPtr)
-    VirtualEventTable *vetPtr;	/* The virtual event table to delete. */
+DeleteVirtualEventTable(
+    VirtualEventTable *vetPtr)	/* The virtual event table to delete. */
 {
     Tcl_HashEntry *hPtr;
     Tcl_HashSearch search;
@@ -2901,11 +2899,11 @@ DeleteVirtualEventTable(vetPtr)
  */
 
 static int
-CreateVirtualEvent(interp, vetPtr, virtString, eventString)
-    Tcl_Interp *interp;		/* Used for error reporting. */
-    VirtualEventTable *vetPtr;	/* Table in which to augment virtual event. */
-    char *virtString;		/* Name of new virtual event. */
-    char *eventString;		/* String describing physical event that
+CreateVirtualEvent(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    VirtualEventTable *vetPtr,	/* Table in which to augment virtual event. */
+    char *virtString,		/* Name of new virtual event. */
+    char *eventString)		/* String describing physical event that
 				 * triggers virtual event. */
 {
     PatSeq *psPtr;
@@ -3009,12 +3007,12 @@ CreateVirtualEvent(interp, vetPtr, virtString, eventString)
  */
 
 static int
-DeleteVirtualEvent(interp, vetPtr, virtString, eventString)
-    Tcl_Interp *interp;		/* Used for error reporting. */
-    VirtualEventTable *vetPtr;	/* Table in which to delete event. */
-    char *virtString;		/* String describing event sequence that
+DeleteVirtualEvent(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    VirtualEventTable *vetPtr,	/* Table in which to delete event. */
+    char *virtString,		/* String describing event sequence that
 				 * triggers binding. */
-    char *eventString;		/* The event sequence that should be deleted,
+    char *eventString)		/* The event sequence that should be deleted,
 				 * or NULL to delete all event sequences for
 				 * the entire virtual event. */
 {
@@ -3169,10 +3167,10 @@ DeleteVirtualEvent(interp, vetPtr, virtString, eventString)
  */
 
 static int
-GetVirtualEvent(interp, vetPtr, virtString)
-    Tcl_Interp *interp;		/* Interpreter for reporting. */
-    VirtualEventTable *vetPtr;	/* Table in which to look for event. */
-    char *virtString;		/* String describing virtual event. */
+GetVirtualEvent(
+    Tcl_Interp *interp,		/* Interpreter for reporting. */
+    VirtualEventTable *vetPtr,	/* Table in which to look for event. */
+    char *virtString)		/* String describing virtual event. */
 {
     Tcl_HashEntry *vhPtr;
     Tcl_DString ds;
@@ -3222,9 +3220,9 @@ GetVirtualEvent(interp, vetPtr, virtString)
  */
 
 static void
-GetAllVirtualEvents(interp, vetPtr)
-    Tcl_Interp *interp;		/* Interpreter returning result. */
-    VirtualEventTable *vetPtr;/* Table containing events. */
+GetAllVirtualEvents(
+    Tcl_Interp *interp,		/* Interpreter returning result. */
+    VirtualEventTable *vetPtr)	/* Table containing events. */
 {
     Tcl_HashEntry *hPtr;
     Tcl_HashSearch search;
@@ -3280,11 +3278,11 @@ GetAllVirtualEvents(interp, vetPtr)
  */
 
 static int
-HandleEventGenerate(interp, mainWin, objc, objv)
-    Tcl_Interp *interp;		/* Interp for errors return and name lookup. */
-    Tk_Window mainWin;		/* Main window associated with interp. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+HandleEventGenerate(
+    Tcl_Interp *interp,		/* Interp for errors return and name lookup. */
+    Tk_Window mainWin,		/* Main window associated with interp. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     XEvent event;
     CONST char *p;
@@ -3317,7 +3315,7 @@ HandleEventGenerate(interp, mainWin, objc, objv)
 	EVENT_X,	EVENT_Y
     };
 
-    windowName = Tcl_GetStringFromObj(objv[0], NULL);
+    windowName = Tcl_GetString(objv[0]);
     if (!windowName[0]) {
 	tkwin = mainWin;
     } else if (NameToWindow(interp, mainWin, objv[0], &tkwin) != TCL_OK) {
@@ -3327,15 +3325,12 @@ HandleEventGenerate(interp, mainWin, objc, objv)
     mainPtr = (TkWindow *) mainWin;
     if ((tkwin == NULL)
 	    || (mainPtr->mainPtr != ((TkWindow *) tkwin)->mainPtr)) {
-	char *name;
-
-	name = Tcl_GetStringFromObj(objv[0], NULL);
-	Tcl_AppendResult(interp, "window id \"", name,
-		"\" doesn't exist in this application", (char *) NULL);
+	Tcl_AppendResult(interp, "window id \"", Tcl_GetString(objv[0]),
+		"\" doesn't exist in this application", NULL);
 	return TCL_ERROR;
     }
 
-    name = Tcl_GetStringFromObj(objv[1], NULL);
+    name = Tcl_GetString(objv[1]);
 
     p = name;
     eventMask = 0;
@@ -3355,7 +3350,7 @@ HandleEventGenerate(interp, mainWin, objc, objv)
 	return TCL_ERROR;
     }
 
-    memset((VOID *) &event, 0, sizeof(event));
+    memset((void *) &event, 0, sizeof(event));
     event.xany.type = pat.eventType;
     event.xany.serial = NextRequest(Tk_Display(tkwin));
     event.xany.send_event = False;
@@ -3422,9 +3417,8 @@ HandleEventGenerate(interp, mainWin, objc, objv)
 	     * is missing.
 	     */
 
-	    Tcl_AppendResult(interp, "value for \"",
-		    Tcl_GetStringFromObj(optionPtr, NULL), "\" missing",
-		    (char *) NULL);
+	    Tcl_AppendResult(interp, "value for \"", Tcl_GetString(optionPtr),
+		    "\" missing", NULL);
 	    return TCL_ERROR;
 	}
 
@@ -3562,18 +3556,18 @@ HandleEventGenerate(interp, mainWin, objc, objv)
 	    KeySym keysym;
 	    char *value;
 
-	    value = Tcl_GetStringFromObj(valuePtr, NULL);
+	    value = Tcl_GetString(valuePtr);
 	    keysym = TkStringToKeysym(value);
 	    if (keysym == NoSymbol) {
 		Tcl_AppendResult(interp, "unknown keysym \"", value, "\"",
-			(char *) NULL);
+			NULL);
 		return TCL_ERROR;
 	    }
 
 	    TkpSetKeycodeAndState(tkwin, keysym, &event);
 	    if (event.xkey.keycode == 0) {
 		Tcl_AppendResult(interp, "no keycode for keysym \"", value,
-			"\"", (char *) NULL);
+			"\"", NULL);
 		return TCL_ERROR;
 	    }
 	    if (!(flags & KEY) || (event.xkey.type == MouseWheelEvent)) {
@@ -3654,7 +3648,7 @@ HandleEventGenerate(interp, mainWin, objc, objv)
 	case EVENT_SEND: {
 	    CONST char *value;
 
-	    value = Tcl_GetStringFromObj(valuePtr, NULL);
+	    value = Tcl_GetString(valuePtr);
 	    if (isdigit(UCHAR(value[0]))) {
 		/*
 		 * Allow arbitrary integer values for the field; they are
@@ -3802,7 +3796,7 @@ HandleEventGenerate(interp, mainWin, objc, objv)
 
     badopt:
 	Tcl_AppendResult(interp, name, " event doesn't accept \"",
-		Tcl_GetStringFromObj(optionPtr, NULL), "\" option", NULL);
+		Tcl_GetString(optionPtr), "\" option", NULL);
 	return TCL_ERROR;
     }
     if (userDataObj != NULL) {
@@ -3850,17 +3844,17 @@ HandleEventGenerate(interp, mainWin, objc, objv)
 }
 
 static int
-NameToWindow(interp, mainWin, objPtr, tkwinPtr)
-    Tcl_Interp *interp;		/* Interp for error return and name lookup. */
-    Tk_Window mainWin;		/* Main window of application. */
-    Tcl_Obj *objPtr;		/* Contains name or id string of window. */
-    Tk_Window *tkwinPtr;	/* Filled with token for window. */
+NameToWindow(
+    Tcl_Interp *interp,		/* Interp for error return and name lookup. */
+    Tk_Window mainWin,		/* Main window of application. */
+    Tcl_Obj *objPtr,		/* Contains name or id string of window. */
+    Tk_Window *tkwinPtr)	/* Filled with token for window. */
 {
     char *name;
     Tk_Window tkwin;
     Window id;
 
-    name = Tcl_GetStringFromObj(objPtr, NULL);
+    name = Tcl_GetString(objPtr);
     if (name[0] == '.') {
 	tkwin = Tk_NameToWindow(interp, name, mainWin);
 	if (tkwin == NULL) {
@@ -3877,7 +3871,7 @@ NameToWindow(interp, mainWin, objPtr, tkwinPtr)
 		((*tkwinPtr = Tk_IdToWindow(Tk_Display(mainWin), id))
 			== NULL)) {
 	    Tcl_AppendResult(interp, "bad window name/identifier \"",
-		    name, "\"", (char *) NULL);
+		    name, "\"", NULL);
 	    return TCL_ERROR;
 	}
     }
@@ -3900,8 +3894,8 @@ NameToWindow(interp, mainWin, objPtr, tkwinPtr)
  *-------------------------------------------------------------------------
  */
 static void
-DoWarp(clientData)
-    ClientData clientData;
+DoWarp(
+    ClientData clientData)
 {
     TkDisplay *dispPtr = (TkDisplay *) clientData;
 
@@ -3932,9 +3926,9 @@ DoWarp(clientData)
  */
 
 static Tk_Uid
-GetVirtualEventUid(interp, virtString)
-    Tcl_Interp *interp;
-    char *virtString;
+GetVirtualEventUid(
+    Tcl_Interp *interp,
+    char *virtString)
 {
     Tk_Uid uid;
     int length;
@@ -3944,7 +3938,7 @@ GetVirtualEventUid(interp, virtString)
     if (length < 5 || virtString[0] != '<' || virtString[1] != '<' ||
 	    virtString[length - 2] != '>' || virtString[length - 1] != '>') {
 	Tcl_AppendResult(interp, "virtual event \"", virtString,
-		"\" is badly formed", (char *) NULL);
+		"\" is badly formed", NULL);
 	return NULL;
     }
     virtString[length - 2] = '\0';
@@ -3979,22 +3973,21 @@ GetVirtualEventUid(interp, virtString)
  */
 
 static PatSeq *
-FindSequence(interp, patternTablePtr, object, eventString, create,
-	allowVirtual, maskPtr)
-    Tcl_Interp *interp;		/* Interpreter to use for error reporting. */
-    Tcl_HashTable *patternTablePtr;
+FindSequence(
+    Tcl_Interp *interp,		/* Interpreter to use for error reporting. */
+    Tcl_HashTable *patternTablePtr,
 				/* Table to use for lookup. */
-    ClientData object;		/* For binding table, token for object with
+    ClientData object,		/* For binding table, token for object with
 				 * which binding is associated. For virtual
 				 * event table, NULL. */
-    CONST char *eventString;	/* String description of pattern to match on.
+    CONST char *eventString,	/* String description of pattern to match on.
 				 * See user documentation for details. */
-    int create;			/* 0 means don't create the entry if it
+    int create,			/* 0 means don't create the entry if it
 				 * doesn't already exist. Non-zero means
 				 * create. */
-    int allowVirtual;		/* 0 means that virtual events are not allowed
+    int allowVirtual,		/* 0 means that virtual events are not allowed
 				 * in the sequence. Non-zero otherwise. */
-    unsigned long *maskPtr;	/* *maskPtr is filled in with the event types
+    unsigned long *maskPtr)	/* *maskPtr is filled in with the event types
 				 * on which this pattern sequence depends. */
 {
     Pattern pats[EVENT_BUFFER_SIZE];
@@ -4121,7 +4114,7 @@ FindSequence(interp, patternTablePtr, object, eventString, create,
     psPtr->nextObjPtr = NULL;
     Tcl_SetHashValue(hPtr, psPtr);
 
-    memcpy((VOID *) psPtr->pats, (VOID *) patPtr, sequenceSize);
+    memcpy((void *) psPtr->pats, (void *) patPtr, sequenceSize);
 
   done:
     *maskPtr = eventMask;
@@ -4150,14 +4143,14 @@ FindSequence(interp, patternTablePtr, object, eventString, create,
  */
 
 static int
-ParseEventDescription(interp, eventStringPtr, patPtr, eventMaskPtr)
-    Tcl_Interp *interp;		/* For error messages. */
-    CONST char **eventStringPtr;/* On input, holds a pointer to start of event
+ParseEventDescription(
+    Tcl_Interp *interp,		/* For error messages. */
+    CONST char **eventStringPtr,/* On input, holds a pointer to start of event
 				 * string. On exit, gets pointer to rest of
 				 * string after parsed event. */
-    Pattern *patPtr;		/* Filled with the pattern parsed from the
+    Pattern *patPtr,		/* Filled with the pattern parsed from the
 				 * event string. */
-    unsigned long *eventMaskPtr;/* Filled with event mask of matched event. */
+    unsigned long *eventMaskPtr)/* Filled with event mask of matched event. */
 {
     char *p;
     unsigned long eventMask;
@@ -4308,7 +4301,7 @@ ParseEventDescription(interp, eventStringPtr, patPtr, eventMaskPtr)
 		goto getKeysym;
 	    } else if ((eventFlags & BUTTON) == 0) {
 		Tcl_AppendResult(interp, "specified button \"", field,
-			"\" for non-button event", (char *) NULL);
+			"\" for non-button event", NULL);
 		count = 0;
 		goto done;
 	    }
@@ -4319,7 +4312,7 @@ ParseEventDescription(interp, eventStringPtr, patPtr, eventMaskPtr)
 	    patPtr->detail.keySym = TkStringToKeysym(field);
 	    if (patPtr->detail.keySym == NoSymbol) {
 		Tcl_AppendResult(interp, "bad event type or keysym \"",
-			field, "\"", (char *) NULL);
+			field, "\"", NULL);
 		count = 0;
 		goto done;
 	    }
@@ -4328,7 +4321,7 @@ ParseEventDescription(interp, eventStringPtr, patPtr, eventMaskPtr)
 		eventMask = KeyPressMask;
 	    } else if ((eventFlags & KEY) == 0) {
 		Tcl_AppendResult(interp, "specified keysym \"", field,
-			"\" for non-key event", (char *) NULL);
+			"\" for non-key event", NULL);
 		count = 0;
 		goto done;
 	    }
@@ -4390,10 +4383,10 @@ ParseEventDescription(interp, eventStringPtr, patPtr, eventMaskPtr)
  */
 
 static char *
-GetField(p, copy, size)
-    char *p;			/* Pointer to part of pattern. */
-    char *copy;			/* Place to copy field. */
-    int size;			/* Maximum number of characters to copy. */
+GetField(
+    char *p,			/* Pointer to part of pattern. */
+    char *copy,			/* Place to copy field. */
+    int size)			/* Maximum number of characters to copy. */
 {
     while ((*p != '\0') && !isspace(UCHAR(*p)) && (*p != '>')
 	    && (*p != '-') && (size > 1)) {
@@ -4425,9 +4418,9 @@ GetField(p, copy, size)
  */
 
 static void
-GetPatternString(psPtr, dsPtr)
-    PatSeq *psPtr;
-    Tcl_DString *dsPtr;
+GetPatternString(
+    PatSeq *psPtr,
+    Tcl_DString *dsPtr)
 {
     Pattern *patPtr;
     char c, buffer[TCL_INTEGER_SPACE];
@@ -4554,8 +4547,8 @@ GetPatternString(psPtr, dsPtr)
  */
 
 static void
-FreeTclBinding(clientData)
-    ClientData clientData;
+FreeTclBinding(
+    ClientData clientData)
 {
     ckfree((char *) clientData);
 }
@@ -4578,8 +4571,8 @@ FreeTclBinding(clientData)
  */
 
 KeySym
-TkStringToKeysym(name)
-    char *name;			/* Name of a keysym. */
+TkStringToKeysym(
+    char *name)			/* Name of a keysym. */
 {
 #ifdef REDO_KEYSYM_LOOKUP
     Tcl_HashEntry *hPtr;
@@ -4617,8 +4610,8 @@ TkStringToKeysym(name)
  */
 
 char *
-TkKeysymToString(keysym)
-    KeySym keysym;
+TkKeysymToString(
+    KeySym keysym)
 {
 #ifdef REDO_KEYSYM_LOOKUP
     Tcl_HashEntry *hPtr;
@@ -4651,9 +4644,9 @@ TkKeysymToString(keysym)
  */
 
 int
-TkCopyAndGlobalEval(interp, script)
-    Tcl_Interp *interp;		/* Interpreter in which to evaluate script. */
-    char *script;		/* Script to evaluate. */
+TkCopyAndGlobalEval(
+    Tcl_Interp *interp,		/* Interpreter in which to evaluate script. */
+    char *script)		/* Script to evaluate. */
 {
     Tcl_DString buffer;
     int code;
@@ -4685,8 +4678,8 @@ TkCopyAndGlobalEval(interp, script)
  */
 
 XEvent *
-TkpGetBindingXEvent(interp)
-    Tcl_Interp *interp;		/* Interpreter. */
+TkpGetBindingXEvent(
+    Tcl_Interp *interp)		/* Interpreter. */
 {
    TkWindow *winPtr = (TkWindow *) Tk_MainWindow(interp);
    BindingTable *bindPtr = (BindingTable *) winPtr->mainPtr->bindingTable;
diff --git a/generic/tkBitmap.c b/generic/tkBitmap.c
index c35ddb1..38b7a34 100644
--- a/generic/tkBitmap.c
+++ b/generic/tkBitmap.c
@@ -1,17 +1,17 @@
-/* 
+/*
  * tkBitmap.c --
  *
  *	This file maintains a database of read-only bitmaps for the Tk
- *	toolkit.  This allows bitmaps to be shared between widgets and
- *	also avoids interactions with the X server.
+ *	toolkit. This allows bitmaps to be shared between widgets and also
+ *	avoids interactions with the X server.
  *
  * Copyright (c) 1990-1994 The Regents of the University of California.
  * Copyright (c) 1994-1998 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: tkBitmap.c,v 1.12 2004/10/19 15:25:05 dkf Exp $
+ * RCS: @(#) $Id: tkBitmap.c,v 1.13 2005/11/04 11:52:50 dkf Exp $
  */
 
 #include "tkPort.h"
@@ -20,10 +20,10 @@
 /*
  * The includes below are for pre-defined bitmaps.
  *
- * Platform-specific issue: Windows complains when the bitmaps are
- * included, because an array of characters is being initialized with
- * integers as elements.  For lint purposes, the following pragmas
- * temporarily turn off that warning message.
+ * Platform-specific issue: Windows complains when the bitmaps are included,
+ * because an array of characters is being initialized with integers as
+ * elements. For lint purposes, the following pragmas temporarily turn off
+ * that warning message.
  */
 
 #if defined(__WIN32__) || defined(_WIN32)
@@ -47,43 +47,43 @@
 
 /*
  * One of the following data structures exists for each bitmap that is
- * currently in use.  Each structure is indexed with both "idTable" and
+ * currently in use. Each structure is indexed with both "idTable" and
  * "nameTable".
  */
 
 typedef struct TkBitmap {
-    Pixmap bitmap;		/* X identifier for bitmap.  None means this
-				 * bitmap was created by Tk_DefineBitmap
-				 * and it isn't currently in use. */
+    Pixmap bitmap;		/* X identifier for bitmap. None means this
+				 * bitmap was created by Tk_DefineBitmap and
+				 * it isn't currently in use. */
     int width, height;		/* Dimensions of bitmap. */
     Display *display;		/* Display for which bitmap is valid. */
     int screenNum;		/* Screen on which bitmap is valid */
     int resourceRefCount;	/* Number of active uses of this bitmap (each
 				 * active use corresponds to a call to
-				 * Tk_AllocBitmapFromObj or Tk_GetBitmap).
-				 * If this count is 0, then this TkBitmap
+				 * Tk_AllocBitmapFromObj or Tk_GetBitmap). If
+				 * this count is 0, then this TkBitmap
 				 * structure is no longer valid and it isn't
 				 * present in nameTable: it is being kept
 				 * around only because there are objects
-				 * referring to it.  The structure is freed
-				 * when resourceRefCount and objRefCount
-				 * are both 0. */
-    int objRefCount;		/* Number of Tcl_Obj's that reference
-				 * this structure. */
+				 * referring to it. The structure is freed
+				 * when resourceRefCount and objRefCount are
+				 * both 0. */
+    int objRefCount;		/* Number of Tcl_Obj's that reference this
+				 * structure. */
     Tcl_HashEntry *nameHashPtr;	/* Entry in nameTable for this structure
 				 * (needed when deleting). */
-    Tcl_HashEntry *idHashPtr;	/* Entry in idTable for this structure
-				 * (needed when deleting). */
+    Tcl_HashEntry *idHashPtr;	/* Entry in idTable for this structure (needed
+				 * when deleting). */
     struct TkBitmap *nextPtr;	/* Points to the next TkBitmap structure with
-				 * the same name.  All bitmaps with the
-				 * same name (but different displays or
-				 * screens) are chained together off a 
-				 * single entry in nameTable. */
+				 * the same name. All bitmaps with the same
+				 * name (but different displays or screens)
+				 * are chained together off a single entry in
+				 * nameTable. */
 } TkBitmap;
 
-/* 
- * Used in bitmapDataTable, stored in the TkDisplay structure, to map
- * between in-core data about a bitmap to its TkBitmap structure.
+/*
+ * Used in bitmapDataTable, stored in the TkDisplay structure, to map between
+ * in-core data about a bitmap to its TkBitmap structure.
  */
 
 typedef struct {
@@ -94,35 +94,33 @@ typedef struct {
 typedef struct ThreadSpecificData {
     int initialized;            /* 0 means table below needs initializing. */
     Tcl_HashTable predefBitmapTable;
-                                /* Hash table created by Tk_DefineBitmap 
-				 * to map from a name to a collection 
-				 * of in-core data about a bitmap.  The 
-				 * table is indexed by the address of the 
-				 * data for the bitmap, and the entries
-				 * contain pointers to TkPredefBitmap 
-				 * structures. */
+                                /* Hash table created by Tk_DefineBitmap to
+				 * map from a name to a collection of in-core
+				 * data about a bitmap. The table is indexed
+				 * by the address of the data for the bitmap,
+				 * and the entries contain pointers to
+				 * TkPredefBitmap structures. */
 } ThreadSpecificData;
 static Tcl_ThreadDataKey dataKey;
 
 /*
- * Forward declarations for procedures defined in this file:
+ * Forward declarations for functions defined in this file:
  */
 
-static void		BitmapInit _ANSI_ARGS_((TkDisplay *dispPtr));
-static void		DupBitmapObjProc _ANSI_ARGS_((Tcl_Obj *srcObjPtr,
-			    Tcl_Obj *dupObjPtr));
-static void		FreeBitmap _ANSI_ARGS_((TkBitmap *bitmapPtr));
-static void		FreeBitmapObjProc _ANSI_ARGS_((Tcl_Obj *objPtr));
-static TkBitmap *	GetBitmap _ANSI_ARGS_((Tcl_Interp *interp,
-			    Tk_Window tkwin, CONST char *name));
-static TkBitmap *	GetBitmapFromObj _ANSI_ARGS_((Tk_Window tkwin,
-			    Tcl_Obj *objPtr));
-static void		InitBitmapObj _ANSI_ARGS_((Tcl_Obj *objPtr));
+static void		BitmapInit(TkDisplay *dispPtr);
+static void		DupBitmapObjProc(Tcl_Obj *srcObjPtr,
+			    Tcl_Obj *dupObjPtr);
+static void		FreeBitmap(TkBitmap *bitmapPtr);
+static void		FreeBitmapObjProc(Tcl_Obj *objPtr);
+static TkBitmap *	GetBitmap(Tcl_Interp *interp,
+			    Tk_Window tkwin, CONST char *name);
+static TkBitmap *	GetBitmapFromObj(Tk_Window tkwin, Tcl_Obj *objPtr);
+static void		InitBitmapObj(Tcl_Obj *objPtr);
 
 /*
  * The following structure defines the implementation of the "bitmap" Tcl
- * object, which maps a string bitmap name to a TkBitmap object.  The
- * ptr1 field of the Tcl_Obj points to a TkBitmap object.
+ * object, which maps a string bitmap name to a TkBitmap object. The ptr1
+ * field of the Tcl_Obj points to a TkBitmap object.
  */
 
 Tcl_ObjType tkBitmapObjType = {
@@ -138,33 +136,33 @@ Tcl_ObjType tkBitmapObjType = {
  *
  * Tk_AllocBitmapFromObj --
  *
- *	Given a Tcl_Obj *, map the value to a corresponding
- *	Pixmap structure based on the tkwin given.
+ *	Given a Tcl_Obj *, map the value to a corresponding Pixmap structure
+ *	based on the tkwin given.
  *
  * Results:
- *	The return value is the X identifer for the desired bitmap
- *	(i.e. a Pixmap with a single plane), unless string couldn't be
- *	parsed correctly.  In this case, None is returned and an error
- *	message is left in the interp's result.  The caller should never
- *	modify the bitmap that is returned, and should eventually call
- *	Tk_FreeBitmapFromObj when the bitmap is no longer needed.
+ *	The return value is the X identifer for the desired bitmap (i.e. a
+ *	Pixmap with a single plane), unless string couldn't be parsed
+ *	correctly. In this case, None is returned and an error message is left
+ *	in the interp's result. The caller should never modify the bitmap that
+ *	is returned, and should eventually call Tk_FreeBitmapFromObj when the
+ *	bitmap is no longer needed.
  *
  * Side effects:
  *	The bitmap is added to an internal database with a reference count.
- *	For each call to this procedure, there should eventually be a call
- *	to Tk_FreeBitmapFromObj, so that the database can be cleaned up 
- *	when bitmaps aren't needed anymore.
+ *	For each call to this function, there should eventually be a call to
+ *	Tk_FreeBitmapFromObj, so that the database can be cleaned up when
+ *	bitmaps aren't needed anymore.
  *
  *----------------------------------------------------------------------
  */
 
 Pixmap
-Tk_AllocBitmapFromObj(interp, tkwin, objPtr)
-    Tcl_Interp *interp;		/* Interp for error results. This may 
-				 * be NULL. */
-    Tk_Window tkwin;		/* Need the screen the bitmap is used on.*/
-    Tcl_Obj *objPtr;		/* Object describing bitmap; see manual
-				 * entry for legal syntax of string value. */
+Tk_AllocBitmapFromObj(
+    Tcl_Interp *interp,		/* Interp for error results. This may be
+				 * NULL. */
+    Tk_Window tkwin,		/* Need the screen the bitmap is used on.*/
+    Tcl_Obj *objPtr)		/* Object describing bitmap; see manual entry
+				 * for legal syntax of string value. */
 {
     TkBitmap *bitmapPtr;
 
@@ -174,54 +172,54 @@ Tk_AllocBitmapFromObj(interp, tkwin, objPtr)
     bitmapPtr = (TkBitmap *) objPtr->internalRep.twoPtrValue.ptr1;
 
     /*
-     * If the object currently points to a TkBitmap, see if it's the
-     * one we want.  If so, increment its reference count and return.
+     * If the object currently points to a TkBitmap, see if it's the one we
+     * want. If so, increment its reference count and return.
      */
 
     if (bitmapPtr != NULL) {
 	if (bitmapPtr->resourceRefCount == 0) {
 	    /*
-	     * This is a stale reference: it refers to a TkBitmap that's
-	     * no longer in use.  Clear the reference.
+	     * This is a stale reference: it refers to a TkBitmap that's no
+	     * longer in use. Clear the reference.
 	     */
 
 	    FreeBitmapObjProc(objPtr);
 	    bitmapPtr = NULL;
-	} else if ( (Tk_Display(tkwin) == bitmapPtr->display)
-		&& (Tk_ScreenNumber(tkwin) == bitmapPtr->screenNum) ) {
+	} else if ((Tk_Display(tkwin) == bitmapPtr->display)
+		&& (Tk_ScreenNumber(tkwin) == bitmapPtr->screenNum)) {
 	    bitmapPtr->resourceRefCount++;
 	    return bitmapPtr->bitmap;
 	}
     }
 
     /*
-     * The object didn't point to the TkBitmap that we wanted.  Search
-     * the list of TkBitmaps with the same name to see if one of the
-     * others is the right one.
+     * The object didn't point to the TkBitmap that we wanted. Search the list
+     * of TkBitmaps with the same name to see if one of the others is the
+     * right one.
      */
 
     if (bitmapPtr != NULL) {
-	TkBitmap *firstBitmapPtr =
-		(TkBitmap *) Tcl_GetHashValue(bitmapPtr->nameHashPtr);
+	TkBitmap *firstBitmapPtr = (TkBitmap *)
+		Tcl_GetHashValue(bitmapPtr->nameHashPtr);
 	FreeBitmapObjProc(objPtr);
 	for (bitmapPtr = firstBitmapPtr; bitmapPtr != NULL;
 		bitmapPtr = bitmapPtr->nextPtr) {
-	    if ( (Tk_Display(tkwin) == bitmapPtr->display) &&
-		    (Tk_ScreenNumber(tkwin) == bitmapPtr->screenNum) ) {
+	    if ((Tk_Display(tkwin) == bitmapPtr->display) &&
+		    (Tk_ScreenNumber(tkwin) == bitmapPtr->screenNum)) {
 		bitmapPtr->resourceRefCount++;
 		bitmapPtr->objRefCount++;
-		objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) bitmapPtr;
+		objPtr->internalRep.twoPtrValue.ptr1 = (void *) bitmapPtr;
 		return bitmapPtr->bitmap;
 	    }
 	}
     }
 
     /*
-     * Still no luck.  Call GetBitmap to allocate a new TkBitmap object.
+     * Still no luck. Call GetBitmap to allocate a new TkBitmap object.
      */
 
     bitmapPtr = GetBitmap(interp, tkwin, Tcl_GetString(objPtr));
-    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) bitmapPtr;
+    objPtr->internalRep.twoPtrValue.ptr1 = (void *) bitmapPtr;
     if (bitmapPtr == NULL) {
 	return None;
     }
@@ -234,33 +232,33 @@ Tk_AllocBitmapFromObj(interp, tkwin, objPtr)
  *
  * Tk_GetBitmap --
  *
- *	Given a string describing a bitmap, locate (or create if necessary)
- *	a bitmap that fits the description.
+ *	Given a string describing a bitmap, locate (or create if necessary) a
+ *	bitmap that fits the description.
  *
  * Results:
- *	The return value is the X identifer for the desired bitmap
- *	(i.e. a Pixmap with a single plane), unless string couldn't be
- *	parsed correctly.  In this case, None is returned and an error
- *	message is left in the interp's result.  The caller should never
- *	modify the bitmap that is returned, and should eventually call
- *	Tk_FreeBitmap when the bitmap is no longer needed.
+ *	The return value is the X identifer for the desired bitmap (i.e. a
+ *	Pixmap with a single plane), unless string couldn't be parsed
+ *	correctly. In this case, None is returned and an error message is left
+ *	in the interp's result. The caller should never modify the bitmap that
+ *	is returned, and should eventually call Tk_FreeBitmap when the bitmap
+ *	is no longer needed.
  *
  * Side effects:
  *	The bitmap is added to an internal database with a reference count.
- *	For each call to this procedure, there should eventually be a call
- *	to Tk_FreeBitmap, so that the database can be cleaned up when bitmaps
+ *	For each call to this function, there should eventually be a call to
+ *	Tk_FreeBitmap, so that the database can be cleaned up when bitmaps
  *	aren't needed anymore.
  *
  *----------------------------------------------------------------------
  */
 
 Pixmap
-Tk_GetBitmap(interp, tkwin, string)
-    Tcl_Interp *interp;		/* Interpreter to use for error reporting,
+Tk_GetBitmap(
+    Tcl_Interp *interp,		/* Interpreter to use for error reporting,
 				 * this may be NULL. */
-    Tk_Window tkwin;		/* Window in which bitmap will be used. */
-    CONST char *string;		/* Description of bitmap.  See manual entry
-				 * for details on legal syntax. */
+    Tk_Window tkwin,		/* Window in which bitmap will be used. */
+    CONST char *string)		/* Description of bitmap. See manual entry for
+				 * details on legal syntax. */
 {
     TkBitmap *bitmapPtr = GetBitmap(interp, tkwin, string);
     if (bitmapPtr == NULL) {
@@ -274,35 +272,35 @@ Tk_GetBitmap(interp, tkwin, string)
  *
  * GetBitmap --
  *
- *	Given a string describing a bitmap, locate (or create if necessary)
- *	a bitmap that fits the description. This routine returns the
- *	internal data structure for the bitmap. This avoids extra
- *	hash table lookups in Tk_AllocBitmapFromObj.
+ *	Given a string describing a bitmap, locate (or create if necessary) a
+ *	bitmap that fits the description. This routine returns the internal
+ *	data structure for the bitmap. This avoids extra hash table lookups in
+ *	Tk_AllocBitmapFromObj.
  *
  * Results:
- *	The return value is the X identifer for the desired bitmap
- *	(i.e. a Pixmap with a single plane), unless string couldn't be
- *	parsed correctly.  In this case, None is returned and an error
- *	message is left in the interp's result.  The caller should never
- *	modify the bitmap that is returned, and should eventually call
- *	Tk_FreeBitmap when the bitmap is no longer needed.
+ *	The return value is the X identifer for the desired bitmap (i.e. a
+ *	Pixmap with a single plane), unless string couldn't be parsed
+ *	correctly. In this case, None is returned and an error message is left
+ *	in the interp's result. The caller should never modify the bitmap that
+ *	is returned, and should eventually call Tk_FreeBitmap when the bitmap
+ *	is no longer needed.
  *
  * Side effects:
  *	The bitmap is added to an internal database with a reference count.
- *	For each call to this procedure, there should eventually be a call
- *	to Tk_FreeBitmap or Tk_FreeBitmapFromObj, so that the database can
- *	be cleaned up when bitmaps aren't needed anymore.
+ *	For each call to this function, there should eventually be a call to
+ *	Tk_FreeBitmap or Tk_FreeBitmapFromObj, so that the database can be
+ *	cleaned up when bitmaps aren't needed anymore.
  *
  *----------------------------------------------------------------------
  */
 
 static TkBitmap *
-GetBitmap(interp, tkwin, string)
-    Tcl_Interp *interp;		/* Interpreter to use for error reporting,
+GetBitmap(
+    Tcl_Interp *interp,		/* Interpreter to use for error reporting,
 				 * this may be NULL. */
-    Tk_Window tkwin;		/* Window in which bitmap will be used. */
-    CONST char *string;		/* Description of bitmap.  See manual entry
-				 * for details on legal syntax. */
+    Tk_Window tkwin,		/* Window in which bitmap will be used. */
+    CONST char *string)		/* Description of bitmap. See manual entry for
+				 * details on legal syntax. */
 {
     Tcl_HashEntry *nameHashPtr, *predefHashPtr;
     TkBitmap *bitmapPtr, *existingBitmapPtr;
@@ -312,7 +310,7 @@ GetBitmap(interp, tkwin, string)
     int width, height;
     int dummy2;
     TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     if (!dispPtr->bitmapInit) {
@@ -335,11 +333,10 @@ GetBitmap(interp, tkwin, string)
     }
 
     /*
-     * No suitable bitmap exists.  Create a new bitmap from the
-     * information contained in the string.  If the string starts
-     * with "@" then the rest of the string is a file name containing
-     * the bitmap.  Otherwise the string must refer to a bitmap
-     * defined by a call to Tk_DefineBitmap.
+     * No suitable bitmap exists. Create a new bitmap from the information
+     * contained in the string. If the string starts with "@" then the rest of
+     * the string is a file name containing the bitmap. Otherwise the string
+     * must refer to a bitmap defined by a call to Tk_DefineBitmap.
      */
 
     if (*string == '@') {	/* INTL: ISO char */
@@ -348,7 +345,7 @@ GetBitmap(interp, tkwin, string)
 
         if (Tcl_IsSafe(interp)) {
             Tcl_AppendResult(interp, "can't specify bitmap with '@' in a",
-                    " safe interpreter", (char *) NULL);
+                    " safe interpreter", NULL);
             goto error;
         }
 
@@ -368,29 +365,29 @@ GetBitmap(interp, tkwin, string)
 		&bitmap, &dummy2, &dummy2);
 	if (result != BitmapSuccess) {
 	    if (interp != NULL) {
-		Tcl_AppendResult(interp, "error reading bitmap file \"", string,
-		    "\"", (char *) NULL);
+		Tcl_AppendResult(interp, "error reading bitmap file \"",
+			string, "\"", NULL);
 	    }
 	    Tcl_DStringFree(&buffer);
 	    goto error;
 	}
 	Tcl_DStringFree(&buffer);
     } else {
-	predefHashPtr = Tcl_FindHashEntry(&tsdPtr->predefBitmapTable, 
-                string);
+	predefHashPtr = Tcl_FindHashEntry(&tsdPtr->predefBitmapTable, string);
 	if (predefHashPtr == NULL) {
 	    /*
-	     * The following platform specific call allows the user to
-	     * define bitmaps that may only exist during run time.  If
-	     * it returns None nothing was found and we return the error.
+	     * The following platform specific call allows the user to define
+	     * bitmaps that may only exist during run time. If it returns None
+	     * nothing was found and we return the error.
 	     */
+
 	    bitmap = TkpGetNativeAppBitmap(Tk_Display(tkwin), string,
 		    &width, &height);
-	    
+
 	    if (bitmap == None) {
 		if (interp != NULL) {
 		    Tcl_AppendResult(interp, "bitmap \"", string,
-			"\" not defined", (char *) NULL);
+			    "\" not defined", NULL);
 		}
 		goto error;
 	    }
@@ -406,9 +403,8 @@ GetBitmap(interp, tkwin, string)
 		}
 	    } else {
 		bitmap = XCreateBitmapFromData(Tk_Display(tkwin),
-		    RootWindowOfScreen(Tk_Screen(tkwin)), 
-		    predefPtr->source,
-		    (unsigned) width, (unsigned) height);
+			RootWindowOfScreen(Tk_Screen(tkwin)),
+			predefPtr->source, (unsigned)width, (unsigned)height);
 	    }
 	}
     }
@@ -426,7 +422,7 @@ GetBitmap(interp, tkwin, string)
     bitmapPtr->resourceRefCount = 1;
     bitmapPtr->objRefCount = 0;
     bitmapPtr->nameHashPtr = nameHashPtr;
-    bitmapPtr->idHashPtr = Tcl_CreateHashEntry(&dispPtr->bitmapIdTable, 
+    bitmapPtr->idHashPtr = Tcl_CreateHashEntry(&dispPtr->bitmapIdTable,
             (char *) bitmap, &new);
     if (!new) {
 	Tcl_Panic("bitmap already registered in Tk_GetBitmap");
@@ -436,7 +432,7 @@ GetBitmap(interp, tkwin, string)
     Tcl_SetHashValue(bitmapPtr->idHashPtr, bitmapPtr);
     return bitmapPtr;
 
-    error:
+  error:
     if (new) {
 	Tcl_DeleteHashEntry(nameHashPtr);
     }
@@ -448,53 +444,53 @@ GetBitmap(interp, tkwin, string)
  *
  * Tk_DefineBitmap --
  *
- *	This procedure associates a textual name with a binary bitmap
- *	description, so that the name may be used to refer to the
- *	bitmap in future calls to Tk_GetBitmap.
+ *	This function associates a textual name with a binary bitmap
+ *	description, so that the name may be used to refer to the bitmap in
+ *	future calls to Tk_GetBitmap.
  *
  * Results:
- *	A standard Tcl result.  If an error occurs then TCL_ERROR is
- *	returned and a message is left in the interp's result.
+ *	A standard Tcl result. If an error occurs then TCL_ERROR is returned
+ *	and a message is left in the interp's result.
  *
  * Side effects:
- *	"Name" is entered into the bitmap table and may be used from
- *	here on to refer to the given bitmap.
+ *	"Name" is entered into the bitmap table and may be used from here on
+ *	to refer to the given bitmap.
  *
  *----------------------------------------------------------------------
  */
 
 int
-Tk_DefineBitmap(interp, name, source, width, height)
-    Tcl_Interp *interp;		/* Interpreter to use for error reporting. */
-    CONST char *name;		/* Name to use for bitmap.  Must not already
-				 * be defined as a bitmap. */
-    CONST char *source;		/* Address of bits for bitmap. */
-    int width;			/* Width of bitmap. */
-    int height;			/* Height of bitmap. */
+Tk_DefineBitmap(
+    Tcl_Interp *interp,		/* Interpreter to use for error reporting. */
+    CONST char *name,		/* Name to use for bitmap. Must not already be
+				 * defined as a bitmap. */
+    CONST char *source,		/* Address of bits for bitmap. */
+    int width,			/* Width of bitmap. */
+    int height)			/* Height of bitmap. */
 {
     int new;
     Tcl_HashEntry *predefHashPtr;
     TkPredefBitmap *predefPtr;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
-    /* 
+    /*
      * Initialize the Bitmap module if not initialized already for this
-     * thread.  Since the current TkDisplay structure cannot be 
-     * introspected from here, pass a NULL pointer to BitmapInit,
-     * which will know to initialize only the data in the 
-     * ThreadSpecificData structure for the current thread.
-     */ 
+     * thread. Since the current TkDisplay structure cannot be introspected
+     * from here, pass a NULL pointer to BitmapInit, which will know to
+     * initialize only the data in the ThreadSpecificData structure for the
+     * current thread.
+     */
 
     if (!tsdPtr->initialized) {
-	BitmapInit((TkDisplay *) NULL);
+	BitmapInit(NULL);
     }
 
-    predefHashPtr = Tcl_CreateHashEntry(&tsdPtr->predefBitmapTable, 
+    predefHashPtr = Tcl_CreateHashEntry(&tsdPtr->predefBitmapTable,
             name, &new);
     if (!new) {
         Tcl_AppendResult(interp, "bitmap \"", name,
-		"\" is already defined", (char *) NULL);
+		"\" is already defined", NULL);
 	return TCL_ERROR;
     }
     predefPtr = (TkPredefBitmap *) ckalloc(sizeof(TkPredefBitmap));
@@ -511,8 +507,7 @@ Tk_DefineBitmap(interp, name, source, width, height)
  *
  * Tk_NameOfBitmap --
  *
- *	Given a bitmap, return a textual string identifying the
- *	bitmap.
+ *	Given a bitmap, return a textual string identifying the bitmap.
  *
  * Results:
  *	The return value is the string name associated with bitmap.
@@ -524,17 +519,16 @@ Tk_DefineBitmap(interp, name, source, width, height)
  */
 
 CONST char *
-Tk_NameOfBitmap(display, bitmap)
-    Display *display;			/* Display for which bitmap was
-					 * allocated. */
-    Pixmap bitmap;			/* Bitmap whose name is wanted. */
+Tk_NameOfBitmap(
+    Display *display,		/* Display for which bitmap was allocated. */
+    Pixmap bitmap)		/* Bitmap whose name is wanted. */
 {
     Tcl_HashEntry *idHashPtr;
     TkBitmap *bitmapPtr;
     TkDisplay *dispPtr = TkGetDisplay(display);
 
     if (dispPtr == NULL || !dispPtr->bitmapInit) {
-	unknown:
+    unknown:
 	Tcl_Panic("Tk_NameOfBitmap received unknown bitmap argument");
     }
 
@@ -551,34 +545,32 @@ Tk_NameOfBitmap(display, bitmap)
  *
  * Tk_SizeOfBitmap --
  *
- *	Given a bitmap managed by this module, returns the width
- *	and height of the bitmap.
+ *	Given a bitmap managed by this module, returns the width and height of
+ *	the bitmap.
  *
  * Results:
- *	The words at *widthPtr and *heightPtr are filled in with
- *	the dimenstions of bitmap.
+ *	The words at *widthPtr and *heightPtr are filled in with the
+ *	dimenstions of bitmap.
  *
  * Side effects:
- *	If bitmap isn't managed by this module then the procedure
- *	panics..
+ *	If bitmap isn't managed by this module then the function panics..
  *
  *--------------------------------------------------------------
  */
 
 void
-Tk_SizeOfBitmap(display, bitmap, widthPtr, heightPtr)
-    Display *display;			/* Display for which bitmap was
-					 * allocated. */
-    Pixmap bitmap;			/* Bitmap whose size is wanted. */
-    int *widthPtr;			/* Store bitmap width here. */
-    int *heightPtr;			/* Store bitmap height here. */
+Tk_SizeOfBitmap(
+    Display *display,		/* Display for which bitmap was allocated. */
+    Pixmap bitmap,		/* Bitmap whose size is wanted. */
+    int *widthPtr,		/* Store bitmap width here. */
+    int *heightPtr)		/* Store bitmap height here. */
 {
     Tcl_HashEntry *idHashPtr;
     TkBitmap *bitmapPtr;
     TkDisplay *dispPtr = TkGetDisplay(display);
 
     if (!dispPtr->bitmapInit) {
-	unknownBitmap:
+    unknownBitmap:
 	Tcl_Panic("Tk_SizeOfBitmap received unknown bitmap argument");
     }
 
@@ -596,23 +588,23 @@ Tk_SizeOfBitmap(display, bitmap, widthPtr, heightPtr)
  *
  * FreeBitmap --
  *
- *	This procedure does all the work of releasing a bitmap allocated by
- *	Tk_GetBitmap or TkGetBitmapFromData.  It is invoked by both
+ *	This function does all the work of releasing a bitmap allocated by
+ *	Tk_GetBitmap or TkGetBitmapFromData. It is invoked by both
  *	Tk_FreeBitmap and Tk_FreeBitmapFromObj
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The reference count associated with bitmap is decremented, and
- *	it is officially deallocated if no-one is using it anymore.
+ *	The reference count associated with bitmap is decremented, and it is
+ *	officially deallocated if no-one is using it anymore.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-FreeBitmap(bitmapPtr)
-    TkBitmap *bitmapPtr;			/* Bitmap to be released. */
+FreeBitmap(
+    TkBitmap *bitmapPtr)	/* Bitmap to be released. */
 {
     TkBitmap *prevPtr;
 
@@ -646,24 +638,23 @@ FreeBitmap(bitmapPtr)
  *
  * Tk_FreeBitmap --
  *
- *	This procedure is called to release a bitmap allocated by
- *	Tk_GetBitmap or TkGetBitmapFromData.
+ *	This function is called to release a bitmap allocated by Tk_GetBitmap
+ *	or TkGetBitmapFromData.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The reference count associated with bitmap is decremented, and
- *	it is officially deallocated if no-one is using it anymore.
+ *	The reference count associated with bitmap is decremented, and it is
+ *	officially deallocated if no-one is using it anymore.
  *
  *----------------------------------------------------------------------
  */
 
 void
-Tk_FreeBitmap(display, bitmap)
-    Display *display;			/* Display for which bitmap was
-					 * allocated. */
-    Pixmap bitmap;			/* Bitmap to be released. */
+Tk_FreeBitmap(
+    Display *display,		/* Display for which bitmap was allocated. */
+    Pixmap bitmap)		/* Bitmap to be released. */
 {
     Tcl_HashEntry *idHashPtr;
     TkDisplay *dispPtr = TkGetDisplay(display);
@@ -684,27 +675,27 @@ Tk_FreeBitmap(display, bitmap)
  *
  * Tk_FreeBitmapFromObj --
  *
- *	This procedure is called to release a bitmap allocated by
- *	Tk_AllocBitmapFromObj. It does not throw away the Tcl_Obj *;
- *	it only gets rid of the hash table entry for this bitmap
- *	and clears the cached value that is normally stored in the object.
+ *	This function is called to release a bitmap allocated by
+ *	Tk_AllocBitmapFromObj. It does not throw away the Tcl_Obj *; it only
+ *	gets rid of the hash table entry for this bitmap and clears the cached
+ *	value that is normally stored in the object.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The reference count associated with the bitmap represented by
- *	objPtr is decremented, and the bitmap is released to X if there are 
- *	no remaining uses for it.
+ *	The reference count associated with the bitmap represented by objPtr
+ *	is decremented, and the bitmap is released to X if there are no
+ *	remaining uses for it.
  *
  *----------------------------------------------------------------------
  */
 
 void
-Tk_FreeBitmapFromObj(tkwin, objPtr)
-    Tk_Window tkwin;		/* The window this bitmap lives in. Needed
-				 * for the display value. */
-    Tcl_Obj *objPtr;		/* The Tcl_Obj * to be freed. */
+Tk_FreeBitmapFromObj(
+    Tk_Window tkwin,		/* The window this bitmap lives in. Needed for
+				 * the display value. */
+    Tcl_Obj *objPtr)		/* The Tcl_Obj * to be freed. */
 {
     FreeBitmap(GetBitmapFromObj(tkwin, objPtr));
 }
@@ -712,26 +703,25 @@ Tk_FreeBitmapFromObj(tkwin, objPtr)
 /*
  *---------------------------------------------------------------------------
  *
- * FreeBitmapObjProc -- 
+ * FreeBitmapObjProc --
  *
  *	This proc is called to release an object reference to a bitmap.
- *	Called when the object's internal rep is released or when
- *	the cached bitmapPtr needs to be changed.
+ *	Called when the object's internal rep is released or when the cached
+ *	bitmapPtr 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 color's resources
- *	are released.
+ *	The object reference count is decremented. When both it and the hash
+ *	ref count go to zero, the color's resources are released.
  *
  *---------------------------------------------------------------------------
  */
 
 static void
-FreeBitmapObjProc(objPtr)
-    Tcl_Obj *objPtr;		/* The object we are releasing. */
+FreeBitmapObjProc(
+    Tcl_Obj *objPtr)		/* The object we are releasing. */
 {
     TkBitmap *bitmapPtr = (TkBitmap *) objPtr->internalRep.twoPtrValue.ptr1;
 
@@ -741,37 +731,37 @@ FreeBitmapObjProc(objPtr)
 		&& (bitmapPtr->resourceRefCount == 0)) {
 	    ckfree((char *) bitmapPtr);
 	}
-	objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) NULL;
+	objPtr->internalRep.twoPtrValue.ptr1 = NULL;
     }
 }
 
 /*
  *---------------------------------------------------------------------------
  *
- * DupBitmapObjProc -- 
+ * DupBitmapObjProc --
  *
- *	When a cached bitmap object is duplicated, this is called to
- *	update the internal reps.
+ *	When a cached bitmap object is duplicated, this is called to update
+ *	the internal reps.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The color's objRefCount is incremented and the internal rep
- *	of the copy is set to point to it.
+ *	The color's objRefCount is incremented and the internal rep of the
+ *	copy is set to point to it.
  *
  *---------------------------------------------------------------------------
  */
 
 static void
-DupBitmapObjProc(srcObjPtr, dupObjPtr)
-    Tcl_Obj *srcObjPtr;		/* The object we are copying from. */
-    Tcl_Obj *dupObjPtr;		/* The object we are copying to. */
+DupBitmapObjProc(
+    Tcl_Obj *srcObjPtr,		/* The object we are copying from. */
+    Tcl_Obj *dupObjPtr)		/* The object we are copying to. */
 {
     TkBitmap *bitmapPtr = (TkBitmap *) srcObjPtr->internalRep.twoPtrValue.ptr1;
-    
+
     dupObjPtr->typePtr = srcObjPtr->typePtr;
-    dupObjPtr->internalRep.twoPtrValue.ptr1 = (VOID *) bitmapPtr;
+    dupObjPtr->internalRep.twoPtrValue.ptr1 = (void *) bitmapPtr;
 
     if (bitmapPtr != NULL) {
 	bitmapPtr->objRefCount++;
@@ -783,22 +773,22 @@ DupBitmapObjProc(srcObjPtr, dupObjPtr)
  *
  * Tk_GetBitmapFromData --
  *
- *	Given a description of the bits for a bitmap, make a bitmap that
- *	has the given properties. *** NOTE:  this procedure is obsolete
- *	and really shouldn't be used anymore. ***
+ *	Given a description of the bits for a bitmap, make a bitmap that has
+ *	the given properties. *** NOTE: this function is obsolete and really
+ *	shouldn't be used anymore. ***
  *
  * Results:
- *	The return value is the X identifer for the desired bitmap
- *	(a one-plane Pixmap), unless it couldn't be created properly.
- *	In this case, None is returned and an error message is left in
- *	the interp's result.  The caller should never modify the bitmap that
- *	is returned, and should eventually call Tk_FreeBitmap when the
- *	bitmap is no longer needed.
+ *	The return value is the X identifer for the desired bitmap (a
+ *	one-plane Pixmap), unless it couldn't be created properly. In this
+ *	case, None is returned and an error message is left in the interp's
+ *	result. The caller should never modify the bitmap that is returned,
+ *	and should eventually call Tk_FreeBitmap when the bitmap is no longer
+ *	needed.
  *
  * Side effects:
  *	The bitmap is added to an internal database with a reference count.
- *	For each call to this procedure, there should eventually be a call
- *	to Tk_FreeBitmap, so that the database can be cleaned up when bitmaps
+ *	For each call to this function, there should eventually be a call to
+ *	Tk_FreeBitmap, so that the database can be cleaned up when bitmaps
  *	aren't needed anymore.
  *
  *----------------------------------------------------------------------
@@ -806,11 +796,11 @@ DupBitmapObjProc(srcObjPtr, dupObjPtr)
 
 	/* ARGSUSED */
 Pixmap
-Tk_GetBitmapFromData(interp, tkwin, source, width, height)
-    Tcl_Interp *interp;		/* Interpreter to use for error reporting. */
-    Tk_Window tkwin;		/* Window in which bitmap will be used. */
-    CONST char *source;		/* Bitmap data for bitmap shape. */
-    int width, height;		/* Dimensions of bitmap. */
+Tk_GetBitmapFromData(
+    Tcl_Interp *interp,		/* Interpreter to use for error reporting. */
+    Tk_Window tkwin,		/* Window in which bitmap will be used. */
+    CONST char *source,		/* Bitmap data for bitmap shape. */
+    int width, int height)	/* Dimensions of bitmap. */
 {
     DataKey nameKey;
     Tcl_HashEntry *dataHashPtr;
@@ -824,7 +814,7 @@ Tk_GetBitmapFromData(interp, tkwin, source, width, height)
     nameKey.source = source;
     nameKey.width = width;
     nameKey.height = height;
-    dataHashPtr = Tcl_CreateHashEntry(&dispPtr->bitmapDataTable, 
+    dataHashPtr = Tcl_CreateHashEntry(&dispPtr->bitmapDataTable,
             (char *) &nameKey, &new);
     if (!new) {
 	name = (char *) Tcl_GetHashValue(dataHashPtr);
@@ -846,25 +836,25 @@ Tk_GetBitmapFromData(interp, tkwin, source, width, height)
  *
  * Tk_GetBitmapFromObj --
  *
- *	Returns the bitmap referred to by a Tcl object.  The bitmap must
- *	already have been allocated via a call to Tk_AllocBitmapFromObj
- *	or Tk_GetBitmap.
+ *	Returns the bitmap referred to by a Tcl object. The bitmap must
+ *	already have been allocated via a call to Tk_AllocBitmapFromObj or
+ *	Tk_GetBitmap.
  *
  * Results:
- *	Returns the Pixmap that matches the tkwin and the string rep
- *	of objPtr.
+ *	Returns the Pixmap that matches the tkwin and the string rep of
+ *	objPtr.
  *
  * Side effects:
- *	If the object is not already a bitmap, the conversion will free
- *	any old internal representation. 
+ *	If the object is not already a bitmap, the conversion will free any
+ *	old internal representation.
  *
  *----------------------------------------------------------------------
  */
 
 Pixmap
-Tk_GetBitmapFromObj(tkwin, objPtr)
-    Tk_Window tkwin;
-    Tcl_Obj *objPtr;		/* The object from which to get pixels. */
+Tk_GetBitmapFromObj(
+    Tk_Window tkwin,
+    Tcl_Obj *objPtr)		/* The object from which to get pixels. */
 {
     TkBitmap *bitmapPtr = GetBitmapFromObj(tkwin, objPtr);
     return bitmapPtr->bitmap;
@@ -875,28 +865,28 @@ Tk_GetBitmapFromObj(tkwin, objPtr)
  *
  * GetBitmapFromObj --
  *
- *	Returns the bitmap referred to by a Tcl object.  The bitmap must
- *	already have been allocated via a call to Tk_AllocBitmapFromObj
- *	or Tk_GetBitmap.
+ *	Returns the bitmap referred to by a Tcl object. The bitmap must
+ *	already have been allocated via a call to Tk_AllocBitmapFromObj or
+ *	Tk_GetBitmap.
  *
  * Results:
- *	Returns the TkBitmap * that matches the tkwin and the string rep
- *	of  objPtr.
+ *	Returns the TkBitmap * that matches the tkwin and the string rep of
+ *	objPtr.
  *
  * Side effects:
- *	If the object is not already a bitmap, the conversion will free
- *	any old internal representation. 
+ *	If the object is not already a bitmap, the conversion will free any
+ *	old internal representation.
  *
  *----------------------------------------------------------------------
  */
 
 static TkBitmap *
-GetBitmapFromObj(tkwin, objPtr)
-    Tk_Window tkwin;		/* Window in which the bitmap will be used. */
-    Tcl_Obj *objPtr;		/* The object that describes the desired
+GetBitmapFromObj(
+    Tk_Window tkwin,		/* Window in which the bitmap will be used. */
+    Tcl_Obj *objPtr)		/* The object that describes the desired
 				 * bitmap. */
 {
-    TkBitmap *bitmapPtr; 
+    TkBitmap *bitmapPtr;
     Tcl_HashEntry *hashPtr;
     TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
 
@@ -905,7 +895,7 @@ GetBitmapFromObj(tkwin, objPtr)
     }
 
     bitmapPtr = (TkBitmap *) objPtr->internalRep.twoPtrValue.ptr1;
-    if (bitmapPtr != NULL) { 
+    if (bitmapPtr != NULL) {
 	if ((bitmapPtr->resourceRefCount > 0)
 		&& (Tk_Display(tkwin) == bitmapPtr->display)) {
 	    return bitmapPtr;
@@ -913,28 +903,28 @@ GetBitmapFromObj(tkwin, objPtr)
 	hashPtr = bitmapPtr->nameHashPtr;
 	FreeBitmapObjProc(objPtr);
     } else {
-	hashPtr = Tcl_FindHashEntry(&dispPtr->bitmapNameTable, 
+	hashPtr = Tcl_FindHashEntry(&dispPtr->bitmapNameTable,
                 Tcl_GetString(objPtr));
 	if (hashPtr == NULL) {
 	    goto error;
 	}
-    } 
+    }
 
     /*
-     * At this point we've got a hash table entry, off of which hang
-     * one or more TkBitmap structures.  See if any of them will work.
+     * At this point we've got a hash table entry, off of which hang one or
+     * more TkBitmap structures. See if any of them will work.
      */
 
     for (bitmapPtr = (TkBitmap *) Tcl_GetHashValue(hashPtr);
 	    bitmapPtr != NULL;  bitmapPtr = bitmapPtr->nextPtr) {
 	if (Tk_Display(tkwin) == bitmapPtr->display) {
-	    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) bitmapPtr;
+	    objPtr->internalRep.twoPtrValue.ptr1 = (void *) bitmapPtr;
 	    bitmapPtr->objRefCount++;
 	    return bitmapPtr;
 	}
     }
 
-    error:
+  error:
     Tcl_Panic("GetBitmapFromObj called with non-existent bitmap!");
     /*
      * The following code isn't reached; it's just there to please compilers.
@@ -947,27 +937,27 @@ GetBitmapFromObj(tkwin, objPtr)
  *
  * InitBitmapObj --
  *
- *	Bookeeping procedure to change an objPtr to a bitmap type.
+ *	Bookeeping function to change an objPtr to a bitmap type.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The old internal rep of the object is freed. The internal
- *	rep is cleared. The final form of the object is set
- *	by either Tk_AllocBitmapFromObj or GetBitmapFromObj.
+ *	The old internal rep of the object is freed. The internal rep is
+ *	cleared. The final form of the object is set by either
+ *	Tk_AllocBitmapFromObj or GetBitmapFromObj.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-InitBitmapObj(objPtr)
-    Tcl_Obj *objPtr;		/* The object to convert. */
+InitBitmapObj(
+    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);
@@ -976,21 +966,22 @@ InitBitmapObj(objPtr)
 	(*typePtr->freeIntRepProc)(objPtr);
     }
     objPtr->typePtr = &tkBitmapObjType;
-    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) NULL;
+    objPtr->internalRep.twoPtrValue.ptr1 = NULL;
 }
 
 /*
  *----------------------------------------------------------------------
  *
  * BitmapInit --
- *	Initializes hash tables used by this module.  Initializes 
- *      tables stored in TkDisplay structure if a TkDisplay pointer
- *      is passed in.  Iinitializes the thread-local data
- *      in the current thread's ThreadSpecificData structure.
+ *
+ *	Initializes hash tables used by this module. Initializes tables stored
+ *	in TkDisplay structure if a TkDisplay pointer is passed in. Also
+ *	initializes the thread-local data in the current thread's
+ *	ThreadSpecificData structure.
  *
  * Results:
  *      None.
- *  
+ *
  * Side effects:
  *	Read the code.
  *
@@ -998,18 +989,18 @@ InitBitmapObj(objPtr)
  */
 
 static void
-BitmapInit(dispPtr)
-    TkDisplay *dispPtr;         /* TkDisplay structure encapsulating 
-				 * thread-specific data used by this 
-				 * module, or NULL if unavailable. */
+BitmapInit(
+    TkDisplay *dispPtr)		/* TkDisplay structure encapsulating
+				 * thread-specific data used by this module,
+				 * or NULL if unavailable. */
 {
     Tcl_Interp *dummy;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
-    /* 
-     * First initialize the data in the ThreadSpecificData strucuture,
-     * if needed.
+    /*
+     * First initialize the data in the ThreadSpecificData strucuture, if
+     * needed.
      */
 
     if (!tsdPtr->initialized) {
@@ -1043,25 +1034,25 @@ BitmapInit(dispPtr)
     }
 
     /*
-     * Was a valid TkDisplay pointer passed?  If so, initialize the
-     * Bitmap module tables in that structure.
+     * Was a valid TkDisplay pointer passed? If so, initialize the Bitmap
+     * module tables in that structure.
      */
 
     if (dispPtr != NULL) {
         dispPtr->bitmapInit = 1;
 	Tcl_InitHashTable(&dispPtr->bitmapNameTable, TCL_STRING_KEYS);
-	Tcl_InitHashTable(&dispPtr->bitmapDataTable, sizeof(DataKey)
-                /sizeof(int));
+	Tcl_InitHashTable(&dispPtr->bitmapDataTable,
+		sizeof(DataKey) / sizeof(int));
 
 	/*
-	 * The call below is tricky:  can't use sizeof(IdKey) because it
-	 * gets padded with extra unpredictable bytes on some 64-bit
-	 * machines.
+	 * The call below is tricky: can't use sizeof(IdKey) because it gets
+	 * padded with extra unpredictable bytes on some 64-bit machines.
 	 */
 
 	/*
 	 * The comment above doesn't make sense...
 	 */
+
 	Tcl_InitHashTable(&dispPtr->bitmapIdTable, TCL_ONE_WORD_KEYS);
     }
 }
@@ -1071,8 +1062,8 @@ BitmapInit(dispPtr)
  *
  * TkReadBitmapFile --
  *
- *	Loads a bitmap image in X bitmap format into the specified
- *	drawable.  This is equivelent to the XReadBitmapFile in X.
+ *	Loads a bitmap image in X bitmap format into the specified drawable.
+ *	This is equivelent to the XReadBitmapFile in X.
  *
  * Results:
  *	Sets the size, hotspot, and bitmap on success.
@@ -1084,16 +1075,15 @@ BitmapInit(dispPtr)
  */
 
 int
-TkReadBitmapFile(display, d, filename, width_return, height_return,
-	bitmap_return, x_hot_return, y_hot_return) 
-    Display* display;
-    Drawable d;
-    CONST char* filename;
-    unsigned int* width_return;
-    unsigned int* height_return;
-    Pixmap* bitmap_return;
-    int* x_hot_return;
-    int* y_hot_return;
+TkReadBitmapFile(
+    Display* display,
+    Drawable d,
+    CONST char* filename,
+    unsigned int* width_return,
+    unsigned int* height_return,
+    Pixmap* bitmap_return,
+    int* x_hot_return,
+    int* y_hot_return)
 {
     char *data;
 
@@ -1116,13 +1106,13 @@ TkReadBitmapFile(display, d, filename, width_return, height_return,
  *
  * TkDebugBitmap --
  *
- *	This procedure returns debugging information about a bitmap.
+ *	This function returns debugging information about a bitmap.
  *
  * Results:
  *	The return value is a list with one sublist for each TkBitmap
- *	corresponding to "name".  Each sublist has two elements that
- *	contain the resourceRefCount and objRefCount fields from the
- *	TkBitmap structure.
+ *	corresponding to "name". Each sublist has two elements that contain
+ *	the resourceRefCount and objRefCount fields from the TkBitmap
+ *	structure.
  *
  * Side effects:
  *	None.
@@ -1131,10 +1121,10 @@ TkReadBitmapFile(display, d, filename, width_return, height_return,
  */
 
 Tcl_Obj *
-TkDebugBitmap(tkwin, name)
-    Tk_Window tkwin;		/* The window in which the bitmap will be
-				 * used (not currently used). */
-    char *name;			/* Name of the desired color. */
+TkDebugBitmap(
+    Tk_Window tkwin,		/* The window in which the bitmap will be used
+				 * (not currently used). */
+    char *name)			/* Name of the desired color. */
 {
     TkBitmap *bitmapPtr;
     Tcl_HashEntry *hashPtr;
@@ -1153,7 +1143,7 @@ TkDebugBitmap(tkwin, name)
 	    Tcl_ListObjAppendElement(NULL, objPtr,
 		    Tcl_NewIntObj(bitmapPtr->resourceRefCount));
 	    Tcl_ListObjAppendElement(NULL, objPtr,
-		    Tcl_NewIntObj(bitmapPtr->objRefCount)); 
+		    Tcl_NewIntObj(bitmapPtr->objRefCount));
 	    Tcl_ListObjAppendElement(NULL, resultPtr, objPtr);
 	}
     }
@@ -1164,15 +1154,16 @@ TkDebugBitmap(tkwin, name)
  *----------------------------------------------------------------------
  *
  * TkGetBitmapPredefTable --
- *      This procedure is used by tkMacBitmap.c to access the thread-
- *      specific predefBitmap table that maps from the names of 
- *      the predefined bitmaps to data associated with those 
- *      bitmaps.  It is required because the table is allocated in 
- *      thread-local storage and is not visible outside this file.
+ *
+ *      This function is used by tkMacBitmap.c to access the thread-specific
+ *      predefBitmap table that maps from the names of the predefined bitmaps
+ *      to data associated with those bitmaps. It is required because the
+ *      table is allocated in thread-local storage and is not visible outside
+ *      this file.
 
  * Results:
- *      Returns a pointer to the predefined bitmap hash table for 
- *      the current thread.
+ *      Returns a pointer to the predefined bitmap hash table for the current
+ *      thread.
  *
  * Side effects:
  *	None.
@@ -1181,10 +1172,18 @@ TkDebugBitmap(tkwin, name)
  */
 
 Tcl_HashTable *
-TkGetBitmapPredefTable()
+TkGetBitmapPredefTable(void)
 {
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     return &tsdPtr->predefBitmapTable;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/generic/tkButton.c b/generic/tkButton.c
index b3ed6b0..0b763d1 100644
--- a/generic/tkButton.c
+++ b/generic/tkButton.c
@@ -1,41 +1,41 @@
-/* 
+/*
  * tkButton.c --
  *
- *	This module implements a collection of button-like
- *	widgets for the Tk toolkit.  The widgets implemented
- *	include labels, buttons, checkbuttons, and radiobuttons.
+ *	This module implements a collection of button-like widgets for the Tk
+ *	toolkit. The widgets implemented include buttons, checkbuttons,
+ *	radiobuttons, and labels.
  *
  * Copyright (c) 1990-1994 The Regents of the University of California.
  * Copyright (c) 1994-1998 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: tkButton.c,v 1.23 2004/02/18 00:40:24 hobbs Exp $
+ * RCS: @(#) $Id: tkButton.c,v 1.24 2005/11/04 11:52:50 dkf Exp $
  */
 
 #include "tkButton.h"
 #include "default.h"
 
-typedef struct ThreadSpecificData { 
+typedef struct ThreadSpecificData {
     int defaultsInitialized;
 } ThreadSpecificData;
 static Tcl_ThreadDataKey dataKey;
 
 /*
- * Class names for buttons, indexed by one of the type values defined
- * in tkButton.h.
+ * Class names for buttons, indexed by one of the type values defined in
+ * tkButton.h.
  */
 
 static char *classNames[] = {"Label", "Button", "Checkbutton", "Radiobutton"};
 
 /*
- * The following table defines the legal values for the -default option.
- * It is used together with the "enum defaultValue" declaration in tkButton.h.
+ * The following table defines the legal values for the -default option. It is
+ * used together with the "enum defaultValue" declaration in tkButton.h.
  */
 
 static char *defaultStrings[] = {
-    "active", "disabled", "normal", (char *) NULL
+    "active", "disabled", "normal", NULL
 };
 
 /*
@@ -44,7 +44,7 @@ static char *defaultStrings[] = {
  */
 
 static char *stateStrings[] = {
-    "active", "disabled", "normal", (char *) NULL
+    "active", "disabled", "normal", NULL
 };
 
 /*
@@ -53,7 +53,7 @@ static char *stateStrings[] = {
  */
 
 static char *compoundStrings[] = {
-    "bottom", "center", "left", "none", "right", "top", (char *) NULL
+    "bottom", "center", "left", "none", "right", "top", NULL
 };
 
 /*
@@ -73,10 +73,10 @@ static Tk_OptionSpec labelOptionSpecs[] = {
     {TK_OPTION_BORDER, "-background", "background", "Background",
 	DEF_BUTTON_BG_COLOR, -1, Tk_Offset(TkButton, normalBorder),
 	0, (ClientData) DEF_BUTTON_BG_MONO, 0},
-    {TK_OPTION_SYNONYM, "-bd", (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, -1, 0, (ClientData) "-borderwidth", 0},
-    {TK_OPTION_SYNONYM, "-bg", (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, -1, 0, (ClientData) "-background", 0},
+    {TK_OPTION_SYNONYM, "-bd", NULL, NULL,
+	NULL, 0, -1, 0, (ClientData) "-borderwidth", 0},
+    {TK_OPTION_SYNONYM, "-bg", NULL, NULL,
+	NULL, 0, -1, 0, (ClientData) "-background", 0},
     {TK_OPTION_BITMAP, "-bitmap", "bitmap", "Bitmap",
 	DEF_BUTTON_BITMAP, -1, Tk_Offset(TkButton, bitmap),
 	TK_OPTION_NULL_OK, 0, 0},
@@ -93,8 +93,8 @@ static Tk_OptionSpec labelOptionSpecs[] = {
 	"DisabledForeground", DEF_BUTTON_DISABLED_FG_COLOR,
 	-1, Tk_Offset(TkButton, disabledFg), TK_OPTION_NULL_OK,
 	(ClientData) DEF_BUTTON_DISABLED_FG_MONO, 0},
-    {TK_OPTION_SYNONYM, "-fg", "foreground", (char *) NULL,
-	(char *) NULL, 0, -1, 0, (ClientData) "-foreground", 0},
+    {TK_OPTION_SYNONYM, "-fg", "foreground", NULL,
+	NULL, 0, -1, 0, (ClientData) "-foreground", 0},
     {TK_OPTION_FONT, "-font", "font", "Font",
 	DEF_BUTTON_FONT, -1, Tk_Offset(TkButton, tkfont), 0, 0, 0},
     {TK_OPTION_COLOR, "-foreground", "foreground", "Foreground",
@@ -143,8 +143,7 @@ static Tk_OptionSpec labelOptionSpecs[] = {
     {TK_OPTION_PIXELS, "-wraplength", "wrapLength", "WrapLength",
 	DEF_BUTTON_WRAP_LENGTH, Tk_Offset(TkButton, wrapLengthPtr),
 	Tk_Offset(TkButton, wrapLength), 0, 0, 0},
-    {TK_OPTION_END, (char *) NULL, (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, 0, 0, 0}
+    {TK_OPTION_END, NULL, NULL, NULL, NULL, 0, 0, 0, 0}
 };
 
 static Tk_OptionSpec buttonOptionSpecs[] = {
@@ -159,10 +158,10 @@ static Tk_OptionSpec buttonOptionSpecs[] = {
     {TK_OPTION_BORDER, "-background", "background", "Background",
 	DEF_BUTTON_BG_COLOR, -1, Tk_Offset(TkButton, normalBorder),
 	0, (ClientData) DEF_BUTTON_BG_MONO, 0},
-    {TK_OPTION_SYNONYM, "-bd", (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, -1, 0, (ClientData) "-borderwidth", 0},
-    {TK_OPTION_SYNONYM, "-bg", (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, -1, 0, (ClientData) "-background", 0},
+    {TK_OPTION_SYNONYM, "-bd", NULL, NULL,
+	NULL, 0, -1, 0, (ClientData) "-borderwidth", 0},
+    {TK_OPTION_SYNONYM, "-bg", NULL, NULL,
+	NULL, 0, -1, 0, (ClientData) "-background", 0},
     {TK_OPTION_BITMAP, "-bitmap", "bitmap", "Bitmap",
 	DEF_BUTTON_BITMAP, -1, Tk_Offset(TkButton, bitmap),
 	TK_OPTION_NULL_OK, 0, 0},
@@ -185,8 +184,8 @@ static Tk_OptionSpec buttonOptionSpecs[] = {
 	"DisabledForeground", DEF_BUTTON_DISABLED_FG_COLOR,
 	-1, Tk_Offset(TkButton, disabledFg), TK_OPTION_NULL_OK,
 	(ClientData) DEF_BUTTON_DISABLED_FG_MONO, 0},
-    {TK_OPTION_SYNONYM, "-fg", "foreground", (char *) NULL,
-	(char *) NULL, 0, -1, 0, (ClientData) "-foreground", 0},
+    {TK_OPTION_SYNONYM, "-fg", "foreground", NULL,
+	NULL, 0, -1, 0, (ClientData) "-foreground", 0},
     {TK_OPTION_FONT, "-font", "font", "Font",
 	DEF_BUTTON_FONT, -1, Tk_Offset(TkButton, tkfont), 0, 0, 0},
     {TK_OPTION_COLOR, "-foreground", "foreground", "Foreground",
@@ -245,8 +244,7 @@ static Tk_OptionSpec buttonOptionSpecs[] = {
     {TK_OPTION_PIXELS, "-wraplength", "wrapLength", "WrapLength",
 	DEF_BUTTON_WRAP_LENGTH, Tk_Offset(TkButton, wrapLengthPtr),
 	Tk_Offset(TkButton, wrapLength), 0, 0, 0},
-    {TK_OPTION_END, (char *) NULL, (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, -1, 0, 0, 0}
+    {TK_OPTION_END, NULL, NULL, NULL, NULL, 0, -1, 0, 0, 0}
 };
 
 static Tk_OptionSpec checkbuttonOptionSpecs[] = {
@@ -261,10 +259,10 @@ static Tk_OptionSpec checkbuttonOptionSpecs[] = {
     {TK_OPTION_BORDER, "-background", "background", "Background",
 	DEF_BUTTON_BG_COLOR, -1, Tk_Offset(TkButton, normalBorder),
 	0, (ClientData) DEF_BUTTON_BG_MONO, 0},
-    {TK_OPTION_SYNONYM, "-bd", (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, -1, 0, (ClientData) "-borderwidth", 0},
-    {TK_OPTION_SYNONYM, "-bg", (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, -1, 0, (ClientData) "-background", 0},
+    {TK_OPTION_SYNONYM, "-bd", NULL, NULL,
+	NULL, 0, -1, 0, (ClientData) "-borderwidth", 0},
+    {TK_OPTION_SYNONYM, "-bg", NULL, NULL,
+	NULL, 0, -1, 0, (ClientData) "-background", 0},
     {TK_OPTION_BITMAP, "-bitmap", "bitmap", "Bitmap",
 	DEF_BUTTON_BITMAP, -1, Tk_Offset(TkButton, bitmap),
 	TK_OPTION_NULL_OK, 0, 0},
@@ -284,8 +282,8 @@ static Tk_OptionSpec checkbuttonOptionSpecs[] = {
 	"DisabledForeground", DEF_BUTTON_DISABLED_FG_COLOR,
 	-1, Tk_Offset(TkButton, disabledFg), TK_OPTION_NULL_OK,
 	(ClientData) DEF_BUTTON_DISABLED_FG_MONO, 0},
-    {TK_OPTION_SYNONYM, "-fg", "foreground", (char *) NULL,
-	(char *) NULL, 0, -1, 0, (ClientData) "-foreground", 0},
+    {TK_OPTION_SYNONYM, "-fg", "foreground", NULL,
+	NULL, 0, -1, 0, (ClientData) "-foreground", 0},
     {TK_OPTION_FONT, "-font", "font", "Font",
 	DEF_BUTTON_FONT, -1, Tk_Offset(TkButton, tkfont), 0, 0, 0},
     {TK_OPTION_COLOR, "-foreground", "foreground", "Foreground",
@@ -359,8 +357,7 @@ static Tk_OptionSpec checkbuttonOptionSpecs[] = {
     {TK_OPTION_PIXELS, "-wraplength", "wrapLength", "WrapLength",
 	DEF_BUTTON_WRAP_LENGTH, Tk_Offset(TkButton, wrapLengthPtr),
 	Tk_Offset(TkButton, wrapLength), 0, 0, 0},
-    {TK_OPTION_END, (char *) NULL, (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, -1, 0, 0, 0}
+    {TK_OPTION_END, NULL, NULL, NULL, NULL, 0, -1, 0, 0, 0}
 };
 
 static Tk_OptionSpec radiobuttonOptionSpecs[] = {
@@ -375,10 +372,10 @@ static Tk_OptionSpec radiobuttonOptionSpecs[] = {
     {TK_OPTION_BORDER, "-background", "background", "Background",
 	DEF_BUTTON_BG_COLOR, -1, Tk_Offset(TkButton, normalBorder),
 	0, (ClientData) DEF_BUTTON_BG_MONO, 0},
-    {TK_OPTION_SYNONYM, "-bd", (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, -1, 0, (ClientData) "-borderwidth", 0},
-    {TK_OPTION_SYNONYM, "-bg", (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, -1, 0, (ClientData) "-background", 0},
+    {TK_OPTION_SYNONYM, "-bd", NULL, NULL,
+	NULL, 0, -1, 0, (ClientData) "-borderwidth", 0},
+    {TK_OPTION_SYNONYM, "-bg", NULL, NULL,
+	NULL, 0, -1, 0, (ClientData) "-background", 0},
     {TK_OPTION_BITMAP, "-bitmap", "bitmap", "Bitmap",
 	DEF_BUTTON_BITMAP, -1, Tk_Offset(TkButton, bitmap),
 	TK_OPTION_NULL_OK, 0, 0},
@@ -398,8 +395,8 @@ static Tk_OptionSpec radiobuttonOptionSpecs[] = {
 	"DisabledForeground", DEF_BUTTON_DISABLED_FG_COLOR,
 	-1, Tk_Offset(TkButton, disabledFg), TK_OPTION_NULL_OK,
 	(ClientData) DEF_BUTTON_DISABLED_FG_MONO, 0},
-    {TK_OPTION_SYNONYM, "-fg", "foreground", (char *) NULL,
-	(char *) NULL, 0, -1, 0, (ClientData) "-foreground", 0},
+    {TK_OPTION_SYNONYM, "-fg", "foreground", NULL,
+	NULL, 0, -1, 0, (ClientData) "-foreground", 0},
     {TK_OPTION_FONT, "-font", "font", "Font",
 	DEF_BUTTON_FONT, -1, Tk_Offset(TkButton, tkfont), 0, 0, 0},
     {TK_OPTION_COLOR, "-foreground", "foreground", "Foreground",
@@ -472,14 +469,12 @@ static Tk_OptionSpec radiobuttonOptionSpecs[] = {
     {TK_OPTION_PIXELS, "-wraplength", "wrapLength", "WrapLength",
 	DEF_BUTTON_WRAP_LENGTH, Tk_Offset(TkButton, wrapLengthPtr),
 	Tk_Offset(TkButton, wrapLength), 0, 0, 0},
-    {TK_OPTION_END, (char *) NULL, (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, -1, 0, 0, 0}
+    {TK_OPTION_END, NULL, NULL, NULL, NULL, 0, -1, 0, 0, 0}
 };
 
 /*
- * The following table maps from one of the type values defined in
- * tkButton.h, such as TYPE_LABEL, to the option template for that
- * class of widgets.
+ * The following table maps from one of the type values defined in tkButton.h,
+ * such as TYPE_LABEL, to the option template for that class of widgets.
  */
 
 static Tk_OptionSpec *optionSpecs[] = {
@@ -490,18 +485,17 @@ static Tk_OptionSpec *optionSpecs[] = {
 };
 
 /*
- * The following tables define the widget commands supported by
- * each of the classes, and map the indexes into the string tables
- * into a single enumerated type used to dispatch the widget command.
+ * The following tables define the widget commands supported by each of the
+ * classes, and map the indexes into the string tables into a single
+ * enumerated type used to dispatch the widget command.
  */
 
 static CONST char *commandNames[][8] = {
-    {"cget", "configure", (char *) NULL},
-    {"cget", "configure", "flash", "invoke", (char *) NULL},
-    {"cget", "configure", "deselect", "flash", "invoke", "select",
-	    "toggle", (char *) NULL},
+    {"cget", "configure", NULL},
+    {"cget", "configure", "flash", "invoke", NULL},
     {"cget", "configure", "deselect", "flash", "invoke", "select",
-	    (char *) NULL}
+	    "toggle", NULL},
+    {"cget", "configure", "deselect", "flash", "invoke", "select", NULL}
 };
 enum command {
     COMMAND_CGET, COMMAND_CONFIGURE, COMMAND_DESELECT, COMMAND_FLASH,
@@ -517,94 +511,92 @@ static enum command map[][8] = {
 };
 
 /*
- * Forward declarations for procedures defined later in this file:
+ * Forward declarations for functions defined later in this file:
  */
 
-static void		ButtonCmdDeletedProc _ANSI_ARGS_((
-			    ClientData clientData));
-static int		ButtonCreate _ANSI_ARGS_((ClientData clientData,
+static void		ButtonCmdDeletedProc(ClientData clientData);
+static int		ButtonCreate(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[], int type));
-static void		ButtonEventProc _ANSI_ARGS_((ClientData clientData,
-			    XEvent *eventPtr));
-static void		ButtonImageProc _ANSI_ARGS_((ClientData clientData,
+			    Tcl_Obj *CONST objv[], int type);
+static void		ButtonEventProc(ClientData clientData,
+			    XEvent *eventPtr);
+static void		ButtonImageProc(ClientData clientData,
+			    int x, int y, int width, int height,
+			    int imgWidth, int imgHeight);
+static void		ButtonSelectImageProc(ClientData clientData,
 			    int x, int y, int width, int height,
-			    int imgWidth, int imgHeight));
-static void		ButtonSelectImageProc _ANSI_ARGS_((
-			    ClientData clientData, int x, int y, int width,
-			    int height, int imgWidth, int imgHeight));
-static void		ButtonTristateImageProc _ANSI_ARGS_((
-			    ClientData clientData, int x, int y, int width,
-			    int height, int imgWidth, int imgHeight));
-static char *		ButtonTextVarProc _ANSI_ARGS_((ClientData clientData,
+			    int imgWidth, int imgHeight);
+static void		ButtonTristateImageProc(ClientData clientData,
+			    int x, int y, int width, int height,
+			    int imgWidth, int imgHeight);
+static char *		ButtonTextVarProc(ClientData clientData,
 			    Tcl_Interp *interp, CONST char *name1,
-			    CONST char *name2, int flags));
-static char *		ButtonVarProc _ANSI_ARGS_((ClientData clientData,
+			    CONST char *name2, int flags);
+static char *		ButtonVarProc(ClientData clientData,
 			    Tcl_Interp *interp, CONST char *name1,
-			    CONST char *name2, int flags));
-static int		ButtonWidgetObjCmd _ANSI_ARGS_((ClientData clientData,
+			    CONST char *name2, int flags);
+static int		ButtonWidgetObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int		ConfigureButton _ANSI_ARGS_((Tcl_Interp *interp,
-			    TkButton *butPtr, int objc,
-			    Tcl_Obj *CONST objv[]));
-static void		DestroyButton _ANSI_ARGS_((TkButton *butPtr));
+			    Tcl_Obj *CONST objv[]);
+static int		ConfigureButton(Tcl_Interp *interp, TkButton *butPtr,
+			    int objc, Tcl_Obj *CONST objv[]);
+static void		DestroyButton(TkButton *butPtr);
 
 /*
  *--------------------------------------------------------------
  *
  * Tk_ButtonCmd, Tk_CheckbuttonCmd, Tk_LabelCmd, Tk_RadiobuttonCmd --
  *
- *	These procedures are invoked to process the "button", "label",
- *	"radiobutton", and "checkbutton" Tcl commands.  See the
- *	user documentation for details on what they do.
+ *	These functions are invoked to process the "button", "label",
+ *	"radiobutton", and "checkbutton" Tcl commands. See the user
+ *	documentation for details on what they do.
  *
  * Results:
  *	A standard Tcl result.
  *
  * Side effects:
- *	See the user documentation.  These procedures are just wrappers;
- *	they call ButtonCreate to do all of the real work.
+ *	See the user documentation. These functions are just wrappers; they
+ *	call ButtonCreate to do all of the real work.
  *
  *--------------------------------------------------------------
  */
 
 int
-Tk_ButtonObjCmd(clientData, interp, objc, objv)
-    ClientData clientData;	/* Either NULL or pointer to option table. */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument values. */
+Tk_ButtonObjCmd(
+    ClientData clientData,	/* Either NULL or pointer to option table. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument values. */
 {
     return ButtonCreate(clientData, interp, objc, objv, TYPE_BUTTON);
 }
 
 int
-Tk_CheckbuttonObjCmd(clientData, interp, objc, objv)
-    ClientData clientData;	/* Either NULL or pointer to option table. */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument values. */
+Tk_CheckbuttonObjCmd(
+    ClientData clientData,	/* Either NULL or pointer to option table. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument values. */
 {
     return ButtonCreate(clientData, interp, objc, objv, TYPE_CHECK_BUTTON);
 }
 
 int
-Tk_LabelObjCmd(clientData, interp, objc, objv)
-    ClientData clientData;	/* Either NULL or pointer to option table. */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument values. */
+Tk_LabelObjCmd(
+    ClientData clientData,	/* Either NULL or pointer to option table. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument values. */
 {
     return ButtonCreate(clientData, interp, objc, objv, TYPE_LABEL);
 }
 
 int
-Tk_RadiobuttonObjCmd(clientData, interp, objc, objv)
-    ClientData clientData;	/* Either NULL or pointer to option table. */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument values. */
+Tk_RadiobuttonObjCmd(
+    ClientData clientData,	/* Either NULL or pointer to option table. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument values. */
 {
     return ButtonCreate(clientData, interp, objc, objv, TYPE_RADIO_BUTTON);
 }
@@ -614,9 +606,9 @@ Tk_RadiobuttonObjCmd(clientData, interp, objc, objv)
  *
  * ButtonCreate --
  *
- *	This procedure does all the real work of implementing the
- *	"button", "label", "radiobutton", and "checkbutton" Tcl
- *	commands.  See the user documentation for details on what it does.
+ *	This function does all the real work of implementing the "button",
+ *	"label", "radiobutton", and "checkbutton" Tcl commands. See the user
+ *	documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -628,20 +620,20 @@ Tk_RadiobuttonObjCmd(clientData, interp, objc, objv)
  */
 
 static int
-ButtonCreate(clientData, interp, objc, objv, type)
-    ClientData clientData;	/* NULL. */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument values. */
-    int type;			/* Type of button to create: TYPE_LABEL,
+ButtonCreate(
+    ClientData clientData,	/* NULL. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[],	/* Argument values. */
+    int type)			/* Type of button to create: TYPE_LABEL,
 				 * TYPE_BUTTON, TYPE_CHECK_BUTTON, or
 				 * TYPE_RADIO_BUTTON. */
 {
     TkButton *butPtr;
     Tk_OptionTable optionTable;
     Tk_Window tkwin;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
-	Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     if (!tsdPtr->defaultsInitialized) {
 	TkpButtonSetDefaults(optionSpecs[type]);
@@ -658,14 +650,14 @@ ButtonCreate(clientData, interp, objc, objv, type)
      */
 
     tkwin = Tk_CreateWindowFromPath(interp, Tk_MainWindow(interp),
-	    Tcl_GetString(objv[1]), (char *) NULL);
+	    Tcl_GetString(objv[1]), NULL);
     if (tkwin == NULL) {
 	return TCL_ERROR;
     }
 
     /*
-     * Create the option table for this widget class.  If it has already
-     * been created, the cached pointer will be returned.
+     * Create the option table for this widget class. If it has already been
+     * created, the cached pointer will be returned.
      */
 
     optionTable = Tk_CreateOptionTable(interp, optionSpecs[type]);
@@ -770,9 +762,9 @@ ButtonCreate(clientData, interp, objc, objv, type)
  *
  * ButtonWidgetCmd --
  *
- *	This procedure is invoked to process the Tcl command
- *	that corresponds to a widget managed by this module.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the Tcl command that corresponds
+ *	to a widget managed by this module. See the user documentation for
+ *	details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -784,11 +776,11 @@ ButtonCreate(clientData, interp, objc, objv, type)
  */
 
 static int
-ButtonWidgetObjCmd(clientData, interp, objc, objv)
-    ClientData clientData;	/* Information about button widget. */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument values. */
+ButtonWidgetObjCmd(
+    ClientData clientData,	/* Information about button widget. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument values. */
 {
     TkButton *butPtr = (TkButton *) clientData;
     int index;
@@ -807,137 +799,126 @@ ButtonWidgetObjCmd(clientData, interp, objc, objv)
     Tcl_Preserve((ClientData) butPtr);
 
     switch (map[butPtr->type][index]) {
-	case COMMAND_CGET: {
-	    if (objc != 3) {
-		Tcl_WrongNumArgs(interp, 1, objv, "cget option");
-		goto error;
-	    }
-	    objPtr = Tk_GetOptionValue(interp, (char *) butPtr,
-		    butPtr->optionTable, objv[2], butPtr->tkwin);
+    case COMMAND_CGET:
+	if (objc != 3) {
+	    Tcl_WrongNumArgs(interp, 1, objv, "cget option");
+	    goto error;
+	}
+	objPtr = Tk_GetOptionValue(interp, (char *) butPtr,
+		butPtr->optionTable, objv[2], butPtr->tkwin);
+	if (objPtr == NULL) {
+	    goto error;
+	} else {
+	    Tcl_SetObjResult(interp, objPtr);
+	}
+	break;
+
+    case COMMAND_CONFIGURE:
+	if (objc <= 3) {
+	    objPtr = Tk_GetOptionInfo(interp, (char *) butPtr,
+		    butPtr->optionTable, (objc == 3) ? objv[2] : NULL,
+		    butPtr->tkwin);
 	    if (objPtr == NULL) {
-		 goto error;
+		goto error;
 	    } else {
 		Tcl_SetObjResult(interp, objPtr);
 	    }
-	    break;
+	} else {
+	    result = ConfigureButton(interp, butPtr, objc-2, objv+2);
 	}
+	break;
 
-	case COMMAND_CONFIGURE: {
-	    if (objc <= 3) {
-		objPtr = Tk_GetOptionInfo(interp, (char *) butPtr,
-			butPtr->optionTable,
-			(objc == 3) ? objv[2] : (Tcl_Obj *) NULL,
-			butPtr->tkwin);
-		if (objPtr == NULL) {
-		    goto error;
-		} else {
-		    Tcl_SetObjResult(interp, objPtr);
-		}
-	    } else {
-		result = ConfigureButton(interp, butPtr, objc-2, objv+2);
-	    }
-	    break;
+    case COMMAND_DESELECT:
+	if (objc > 2) {
+	    Tcl_WrongNumArgs(interp, 1, objv, "deselect");
+	    goto error;
 	}
-
-	case COMMAND_DESELECT: {
-	    if (objc > 2) {
-		Tcl_WrongNumArgs(interp, 1, objv, "deselect");
+	if (butPtr->type == TYPE_CHECK_BUTTON) {
+	    if (Tcl_ObjSetVar2(interp, butPtr->selVarNamePtr, NULL,
+		    butPtr->offValuePtr, TCL_GLOBAL_ONLY|TCL_LEAVE_ERR_MSG)
+		    == NULL) {
 		goto error;
 	    }
-	    if (butPtr->type == TYPE_CHECK_BUTTON) {
-		if (Tcl_ObjSetVar2(interp, butPtr->selVarNamePtr, NULL,
-			butPtr->offValuePtr, TCL_GLOBAL_ONLY|TCL_LEAVE_ERR_MSG)
-			== NULL) {
-		    goto error;
-		}
-	    } else if (butPtr->flags & SELECTED) {
-		if (Tcl_ObjSetVar2(interp,
-			butPtr->selVarNamePtr, NULL, Tcl_NewObj(),
-			TCL_GLOBAL_ONLY|TCL_LEAVE_ERR_MSG)
-			== NULL) {
-		    goto error;
-		}
+	} else if (butPtr->flags & SELECTED) {
+	    if (Tcl_ObjSetVar2(interp, butPtr->selVarNamePtr, NULL,
+		     Tcl_NewObj(), TCL_GLOBAL_ONLY|TCL_LEAVE_ERR_MSG) == NULL){
+		goto error;
 	    }
-	    break;
 	}
+	break;
 
-	case COMMAND_FLASH: {
+    case COMMAND_FLASH:
+	if (objc > 2) {
+	    Tcl_WrongNumArgs(interp, 1, objv, "flash");
+	    goto error;
+	}
+	if (butPtr->state != STATE_DISABLED) {
 	    int i;
 
-	    if (objc > 2) {
-		Tcl_WrongNumArgs(interp, 1, objv, "flash");
-		goto error;
-	    }
-	    if (butPtr->state != STATE_DISABLED) {
-		for (i = 0; i < 4; i++) {
-		    if (butPtr->state == STATE_NORMAL) {
-			butPtr->state = STATE_ACTIVE; 
-			Tk_SetBackgroundFromBorder(butPtr->tkwin,
-				butPtr->activeBorder);
-		    } else {
-			butPtr->state = STATE_NORMAL; 
-			Tk_SetBackgroundFromBorder(butPtr->tkwin,
-				butPtr->normalBorder);
-		    }
-		    TkpDisplayButton((ClientData) butPtr);
-    
-		    /*
-		     * Special note: must cancel any existing idle handler
-		     * for TkpDisplayButton;  it's no longer needed, and
-		     * TkpDisplayButton cleared the REDRAW_PENDING flag.
-		     */
-    
-		    Tcl_CancelIdleCall(TkpDisplayButton, (ClientData) butPtr);
-		    XFlush(butPtr->display);
-		    Tcl_Sleep(50);
+	    for (i = 0; i < 4; i++) {
+		if (butPtr->state == STATE_NORMAL) {
+		    butPtr->state = STATE_ACTIVE;
+		    Tk_SetBackgroundFromBorder(butPtr->tkwin,
+			    butPtr->activeBorder);
+		} else {
+		    butPtr->state = STATE_NORMAL;
+		    Tk_SetBackgroundFromBorder(butPtr->tkwin,
+			    butPtr->normalBorder);
 		}
+		TkpDisplayButton((ClientData) butPtr);
+
+		/*
+		 * Special note: must cancel any existing idle handler for
+		 * TkpDisplayButton; it's no longer needed, and
+		 * TkpDisplayButton cleared the REDRAW_PENDING flag.
+		 */
+
+		Tcl_CancelIdleCall(TkpDisplayButton, (ClientData) butPtr);
+		XFlush(butPtr->display);
+		Tcl_Sleep(50);
 	    }
-	    break;
 	}
+	break;
 
-	case COMMAND_INVOKE: {
-	    if (objc > 2) {
-		Tcl_WrongNumArgs(interp, 1, objv, "invoke");
-		goto error;
-	    }
-	    if (butPtr->state != STATE_DISABLED) {
-		result = TkInvokeButton(butPtr);
-	    }
-	    break;
+    case COMMAND_INVOKE:
+	if (objc > 2) {
+	    Tcl_WrongNumArgs(interp, 1, objv, "invoke");
+	    goto error;
 	}
+	if (butPtr->state != STATE_DISABLED) {
+	    result = TkInvokeButton(butPtr);
+	}
+	break;
 
-	case COMMAND_SELECT: {
-	    if (objc > 2) {
-		Tcl_WrongNumArgs(interp, 1, objv, "select");
-		goto error;
-	    }
-	    if (Tcl_ObjSetVar2(interp, butPtr->selVarNamePtr, NULL,
-		    butPtr->onValuePtr, TCL_GLOBAL_ONLY|TCL_LEAVE_ERR_MSG)
-		    == NULL) {
-		goto error;
-	    }
-	    break;
+    case COMMAND_SELECT:
+	if (objc > 2) {
+	    Tcl_WrongNumArgs(interp, 1, objv, "select");
+	    goto error;
 	}
+	if (Tcl_ObjSetVar2(interp, butPtr->selVarNamePtr, NULL,
+		butPtr->onValuePtr, TCL_GLOBAL_ONLY|TCL_LEAVE_ERR_MSG)
+		== NULL) {
+	    goto error;
+	}
+	break;
 
-	case COMMAND_TOGGLE: {
-	    if (objc > 2) {
-		Tcl_WrongNumArgs(interp, 1, objv, "toggle");
-		goto error;
-	    }
-	    if (Tcl_ObjSetVar2(interp, butPtr->selVarNamePtr, NULL,
-		    (butPtr->flags & SELECTED) ? butPtr->offValuePtr
-		    : butPtr->onValuePtr,
-		    TCL_GLOBAL_ONLY|TCL_LEAVE_ERR_MSG)
-		    == NULL) {
-		goto error;
-	    }
-	    break;
+    case COMMAND_TOGGLE:
+	if (objc > 2) {
+	    Tcl_WrongNumArgs(interp, 1, objv, "toggle");
+	    goto error;
 	}
+	if (Tcl_ObjSetVar2(interp, butPtr->selVarNamePtr, NULL,
+		(butPtr->flags & SELECTED) ? butPtr->offValuePtr
+		: butPtr->onValuePtr, TCL_GLOBAL_ONLY|TCL_LEAVE_ERR_MSG)
+		== NULL) {
+	    goto error;
+	}
+	break;
     }
     Tcl_Release((ClientData) butPtr);
     return result;
 
-    error:
+  error:
     Tcl_Release((ClientData) butPtr);
     return TCL_ERROR;
 }
@@ -947,8 +928,8 @@ ButtonWidgetObjCmd(clientData, interp, objc, objv)
  *
  * DestroyButton --
  *
- *	This procedure is invoked by ButtonEventProc to free all the
- *	resources of a button and clean up its state.
+ *	This function is invoked by ButtonEventProc to free all the resources
+ *	of a button and clean up its state.
  *
  * Results:
  *	None.
@@ -960,8 +941,8 @@ ButtonWidgetObjCmd(clientData, interp, objc, objv)
  */
 
 static void
-DestroyButton(butPtr)
-    TkButton *butPtr;		/* Info about button widget. */
+DestroyButton(
+    TkButton *butPtr)		/* Info about button widget. */
 {
     butPtr->flags |= BUTTON_DELETED;
     TkpDestroyButton(butPtr);
@@ -971,9 +952,8 @@ DestroyButton(butPtr)
     }
 
     /*
-     * Free up all the stuff that requires special handling, then
-     * let Tk_FreeOptions handle all the standard option-related
-     * stuff.
+     * Free up all the stuff that requires special handling, then let
+     * Tk_FreeOptions handle all the standard option-related stuff.
      */
 
     Tcl_DeleteCommandFromToken(butPtr->interp, butPtr->widgetCmd);
@@ -1028,28 +1008,28 @@ DestroyButton(butPtr)
  *
  * ConfigureButton --
  *
- *	This procedure is called to process an objc/objv list to set
+ *	This function is called to process an objc/objv list to set
  *	configuration options for a button widget.
  *
  * Results:
- *	The return value is a standard Tcl result.  If TCL_ERROR is
- *	returned, then an error message is left in interp's result.
+ *	The return value is a standard Tcl result. If TCL_ERROR is returned,
+ *	then an error message is left in interp's result.
  *
  * Side effects:
- *	Configuration information, such as text string, colors, font,
- *	etc. get set for butPtr;  old resources get freed, if there
- *	were any.  The button is redisplayed.
+ *	Configuration information, such as text string, colors, font, etc. get
+ *	set for butPtr; old resources get freed, if there were any. The button
+ *	is redisplayed.
  *
  *----------------------------------------------------------------------
  */
 
 static int
-ConfigureButton(interp, butPtr, objc, objv)
-    Tcl_Interp *interp;		/* Used for error reporting. */
-    register TkButton *butPtr;	/* Information about widget;  may or may
+ConfigureButton(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    register TkButton *butPtr,	/* Information about widget;  may or may
 				 * not already have values for some fields. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument values. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument values. */
 {
     Tk_SavedOptions savedOptions;
     Tcl_Obj *errorResult = NULL;
@@ -1061,21 +1041,21 @@ ConfigureButton(interp, butPtr, objc, objv)
      */
 
     if (butPtr->textVarNamePtr != NULL) {
-	Tcl_UntraceVar(interp, Tcl_GetString(butPtr->textVarNamePtr), 
+	Tcl_UntraceVar(interp, Tcl_GetString(butPtr->textVarNamePtr),
 		TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
 		ButtonTextVarProc, (ClientData) butPtr);
     }
     if (butPtr->selVarNamePtr != NULL) {
-	Tcl_UntraceVar(interp, Tcl_GetString(butPtr->selVarNamePtr), 
+	Tcl_UntraceVar(interp, Tcl_GetString(butPtr->selVarNamePtr),
 		TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
 		ButtonVarProc, (ClientData) butPtr);
     }
 
     /*
-     * The following loop is potentially executed twice.  During the
-     * first pass configuration options get set to their new values.
-     * If there is an error in this pass, we execute a second pass
-     * to restore all the options to their previous values.
+     * The following loop is potentially executed twice. During the first pass
+     * configuration options get set to their new values. If there is an error
+     * in this pass, we execute a second pass to restore all the options to
+     * their previous values.
      */
 
     for (error = 0; error <= 1; error++) {
@@ -1086,7 +1066,7 @@ ConfigureButton(interp, butPtr, objc, objv)
 
 	    if (Tk_SetOptions(interp, (char *) butPtr,
 		    butPtr->optionTable, objc, objv,
-		    butPtr->tkwin, &savedOptions, (int *) NULL) != TCL_OK) {
+		    butPtr->tkwin, &savedOptions, NULL) != TCL_OK) {
 		continue;
 	    }
 	} else {
@@ -1108,8 +1088,8 @@ ConfigureButton(interp, butPtr, objc, objv)
 
 	/*
 	 * A few options need special processing, such as setting the
-	 * background from a 3-D border, or filling in complicated
-	 * defaults that couldn't be specified to Tk_SetOptions.
+	 * background from a 3-D border, or filling in complicated defaults
+	 * that couldn't be specified to Tk_SetOptions.
 	 */
 
 	if ((butPtr->state == STATE_ACTIVE)
@@ -1133,21 +1113,21 @@ ConfigureButton(interp, butPtr, objc, objv)
 
 	if (butPtr->type >= TYPE_CHECK_BUTTON) {
 	    Tcl_Obj *valuePtr, *namePtr;
-    
+
 	    if (butPtr->selVarNamePtr == NULL) {
 		butPtr->selVarNamePtr = Tcl_NewStringObj(
 			Tk_Name(butPtr->tkwin), -1);
 		Tcl_IncrRefCount(butPtr->selVarNamePtr);
 	    }
 	    namePtr = butPtr->selVarNamePtr;
-    
+
 	    /*
 	     * Select the button if the associated variable has the
-	     * appropriate value, initialize the variable if it doesn't
-	     * exist, then set a trace on the variable to monitor future
-	     * changes to its value.
+	     * appropriate value, initialize the variable if it doesn't exist,
+	     * then set a trace on the variable to monitor future changes to
+	     * its value.
 	     */
-    
+
 	    valuePtr = Tcl_ObjGetVar2(interp, namePtr, NULL, TCL_GLOBAL_ONLY);
 	    butPtr->flags &= ~SELECTED;
             butPtr->flags &= ~TRISTATED;
@@ -1169,8 +1149,8 @@ ConfigureButton(interp, butPtr, objc, objv)
 		}
 
 		/*
-		 * If a radiobutton has the empty string as value
-		 * it should be selected.
+		 * If a radiobutton has the empty string as value it should be
+		 * selected.
 		 */
 
  		if ((butPtr->type == TYPE_RADIO_BUTTON) &&
@@ -1181,11 +1161,11 @@ ConfigureButton(interp, butPtr, objc, objv)
 	}
 
 	/*
-	 * Get the images for the widget, if there are any.  Allocate the
-	 * new images before freeing the old ones, so that the reference
-	 * counts don't go to zero and cause image data to be discarded.
+	 * Get the images for the widget, if there are any. Allocate the new
+	 * images before freeing the old ones, so that the reference counts
+	 * don't go to zero and cause image data to be discarded.
 	 */
-    
+
 	if (butPtr->imagePtr != NULL) {
 	    image = Tk_GetImage(butPtr->interp, butPtr->tkwin,
 		    Tcl_GetString(butPtr->imagePtr), ButtonImageProc,
@@ -1240,7 +1220,7 @@ ConfigureButton(interp, butPtr, objc, objv)
 	     * on the variable's value, create the variable if it doesn't
 	     * exist, and fetch its current value.
 	     */
-    
+
 	    Tcl_Obj *valuePtr, *namePtr;
 
 	    namePtr = butPtr->textVarNamePtr;
@@ -1259,22 +1239,21 @@ ConfigureButton(interp, butPtr, objc, objv)
 		Tcl_IncrRefCount(butPtr->textPtr);
 	    }
 	}
-    
+
 	if ((butPtr->bitmap != None) || (butPtr->imagePtr != NULL)) {
 	    /*
-	     * The button must display the contents of an image or
-	     * bitmap.
+	     * The button must display the contents of an image or bitmap.
 	     */
 
 	    if (Tk_GetPixelsFromObj(interp, butPtr->tkwin, butPtr->widthPtr,
 		    &butPtr->width) != TCL_OK) {
-		widthError:
+	    widthError:
 		Tcl_AddErrorInfo(interp, "\n    (processing -width option)");
 		continue;
 	    }
 	    if (Tk_GetPixelsFromObj(interp, butPtr->tkwin, butPtr->heightPtr,
 		    &butPtr->height) != TCL_OK) {
-		heightError:
+	    heightError:
 		Tcl_AddErrorInfo(interp, "\n    (processing -height option)");
 		continue;
 	    }
@@ -1312,7 +1291,7 @@ ConfigureButton(interp, butPtr, objc, objv)
 		TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
 		ButtonVarProc, (ClientData) butPtr);
     }
-    
+
     TkButtonWorldChanged((ClientData) butPtr);
     if (error) {
 	Tcl_SetObjResult(interp, errorResult);
@@ -1328,9 +1307,9 @@ ConfigureButton(interp, butPtr, objc, objv)
  *
  * TkButtonWorldChanged --
  *
- *      This procedure is called when the world has changed in some
- *      way and the widget needs to recompute all its graphics contexts
- *	and determine its new geometry.
+ *      This function is called when the world has changed in some way and the
+ *      widget needs to recompute all its graphics contexts and determine its
+ *      new geometry.
  *
  * Results:
  *      None.
@@ -1340,10 +1319,10 @@ ConfigureButton(interp, butPtr, objc, objv)
  *
  *---------------------------------------------------------------------------
  */
- 
+
 void
-TkButtonWorldChanged(instanceData)
-    ClientData instanceData;	/* Information about widget. */
+TkButtonWorldChanged(
+    ClientData instanceData)	/* Information about widget. */
 {
     XGCValues gcValues;
     GC newGC;
@@ -1359,7 +1338,7 @@ TkButtonWorldChanged(instanceData)
     gcValues.font = Tk_FontId(butPtr->tkfont);
     gcValues.foreground = butPtr->normalFg->pixel;
     gcValues.background = Tk_3DBorderColor(butPtr->normalBorder)->pixel;
-    
+
     /*
      * Note: GraphicsExpose events are disabled in normalTextGC because it's
      * used to copy stuff from an off-screen pixmap onto the screen (we know
@@ -1406,8 +1385,8 @@ TkButtonWorldChanged(instanceData)
     }
 
     /*
-     * Allocate the disabled graphics context, for drawing text in
-     * its disabled state.
+     * Allocate the disabled graphics context, for drawing text in its
+     * disabled state.
      */
 
     mask = GCForeground | GCBackground | GCFont;
@@ -1443,31 +1422,31 @@ TkButtonWorldChanged(instanceData)
  *
  * ButtonEventProc --
  *
- *	This procedure is invoked by the Tk dispatcher for various
- *	events on buttons.
+ *	This function is invoked by the Tk dispatcher for various events on
+ *	buttons.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	When the window gets deleted, internal structures get
- *	cleaned up.  When it gets exposed, it is redisplayed.
+ *	When the window gets deleted, internal structures get cleaned up. When
+ *	it gets exposed, it is redisplayed.
  *
  *--------------------------------------------------------------
  */
 
 static void
-ButtonEventProc(clientData, eventPtr)
-    ClientData clientData;	/* Information about window. */
-    XEvent *eventPtr;		/* Information about event. */
+ButtonEventProc(
+    ClientData clientData,	/* Information about window. */
+    XEvent *eventPtr)		/* Information about event. */
 {
     TkButton *butPtr = (TkButton *) clientData;
     if ((eventPtr->type == Expose) && (eventPtr->xexpose.count == 0)) {
 	goto redraw;
     } else if (eventPtr->type == ConfigureNotify) {
 	/*
-	 * Must redraw after size changes, since layout could have changed
-	 * and borders will need to be redrawn.
+	 * Must redraw after size changes, since layout could have changed and
+	 * borders will need to be redrawn.
 	 */
 
 	goto redraw;
@@ -1490,7 +1469,7 @@ ButtonEventProc(clientData, eventPtr)
     }
     return;
 
-    redraw:
+  redraw:
     if ((butPtr->tkwin != NULL) && !(butPtr->flags & REDRAW_PENDING)) {
 	Tcl_DoWhenIdle(TkpDisplayButton, (ClientData) butPtr);
 	butPtr->flags |= REDRAW_PENDING;
@@ -1502,9 +1481,9 @@ ButtonEventProc(clientData, eventPtr)
  *
  * ButtonCmdDeletedProc --
  *
- *	This procedure is invoked when a widget command is deleted.  If
- *	the widget isn't already in the process of being destroyed,
- *	this command destroys it.
+ *	This function is invoked when a widget command is deleted. If the
+ *	widget isn't already in the process of being destroyed, this command
+ *	destroys it.
  *
  * Results:
  *	None.
@@ -1516,16 +1495,16 @@ ButtonEventProc(clientData, eventPtr)
  */
 
 static void
-ButtonCmdDeletedProc(clientData)
-    ClientData clientData;	/* Pointer to widget record for widget. */
+ButtonCmdDeletedProc(
+    ClientData clientData)	/* Pointer to widget record for widget. */
 {
     TkButton *butPtr = (TkButton *) clientData;
 
     /*
-     * This procedure could be invoked either because the window was
-     * destroyed and the command was then deleted or because the command
-     * was deleted, and then this procedure destroys the widget.  The
-     * BUTTON_DELETED flag distinguishes these cases.
+     * This function could be invoked either because the window was destroyed
+     * and the command was then deleted or because the command was deleted,
+     * and then this function destroys the widget. The BUTTON_DELETED flag
+     * distinguishes these cases.
      */
 
     if (!(butPtr->flags & BUTTON_DELETED)) {
@@ -1538,14 +1517,14 @@ ButtonCmdDeletedProc(clientData)
  *
  * TkInvokeButton --
  *
- *	This procedure is called to carry out the actions associated
- *	with a button, such as invoking a Tcl command or setting a
- *	variable.  This procedure is invoked, for example, when the
- *	button is invoked via the mouse.
+ *	This function is called to carry out the actions associated with a
+ *	button, such as invoking a Tcl command or setting a variable. This
+ *	function is invoked, for example, when the button is invoked via the
+ *	mouse.
  *
  * Results:
- *	A standard Tcl return value.  Information is also left in
- *	the interp's result.
+ *	A standard Tcl return value. Information is also left in the interp's
+ *	result.
  *
  * Side effects:
  *	Depends on the button and its associated command.
@@ -1554,8 +1533,8 @@ ButtonCmdDeletedProc(clientData)
  */
 
 int
-TkInvokeButton(butPtr)
-    TkButton *butPtr;			/* Information about button. */
+TkInvokeButton(
+    TkButton *butPtr)		/* Information about button. */
 {
     Tcl_Obj *namePtr = butPtr->selVarNamePtr;
 
@@ -1592,10 +1571,9 @@ TkInvokeButton(butPtr)
  *
  * ButtonVarProc --
  *
- *	This procedure is invoked when someone changes the
- *	state variable associated with a radio button.  Depending
- *	on the new value of the button's variable, the button
- *	may be selected or deselected.
+ *	This function is invoked when someone changes the state variable
+ *	associated with a radio button. Depending on the new value of the
+ *	button's variable, the button may be selected or deselected.
  *
  * Results:
  *	NULL is always returned.
@@ -1608,12 +1586,12 @@ TkInvokeButton(butPtr)
 
 	/* ARGSUSED */
 static char *
-ButtonVarProc(clientData, interp, name1, name2, flags)
-    ClientData clientData;	/* Information about button. */
-    Tcl_Interp *interp;		/* Interpreter containing variable. */
-    CONST char *name1;		/* Name of variable. */
-    CONST char *name2;		/* Second part of variable name. */
-    int flags;			/* Information about what happened. */
+ButtonVarProc(
+    ClientData clientData,	/* Information about button. */
+    Tcl_Interp *interp,		/* Interpreter containing variable. */
+    CONST char *name1,		/* Name of variable. */
+    CONST char *name2,		/* Second part of variable name. */
+    int flags)			/* Information about what happened. */
 {
     register TkButton *butPtr = (TkButton *) clientData;
     char *name, *value;
@@ -1622,8 +1600,8 @@ ButtonVarProc(clientData, interp, name1, name2, flags)
     name = Tcl_GetString(butPtr->selVarNamePtr);
 
     /*
-     * If the variable is being unset, then just re-establish the
-     * trace unless the whole interpreter is going away.
+     * If the variable is being unset, then just re-establish the trace unless
+     * the whole interpreter is going away.
      */
 
     if (flags & TCL_TRACE_UNSETS) {
@@ -1638,8 +1616,8 @@ ButtonVarProc(clientData, interp, name1, name2, flags)
     }
 
     /*
-     * Use the value of the variable to update the selected status of
-     * the button.
+     * Use the value of the variable to update the selected status of the
+     * button.
      */
 
     valuePtr = Tcl_GetVar2Ex(interp, name, NULL, TCL_GLOBAL_ONLY);
@@ -1650,29 +1628,29 @@ ButtonVarProc(clientData, interp, name1, name2, flags)
     }
     if (strcmp(value, Tcl_GetString(butPtr->onValuePtr)) == 0) {
 	if (butPtr->flags & SELECTED) {
-	    return (char *) NULL;
+	    return NULL;
 	}
 	butPtr->flags |= SELECTED;
         butPtr->flags &= ~TRISTATED;
     } else if (strcmp(value, Tcl_GetString(butPtr->tristateValuePtr)) == 0) {
         if (butPtr->flags & TRISTATED) {
-            return (char *) NULL;
+            return NULL;
         }
         butPtr->flags |= TRISTATED;
         butPtr->flags &= ~SELECTED;
     } else if (butPtr->flags & (SELECTED | TRISTATED)) {
 	butPtr->flags &= ~(SELECTED | TRISTATED);
     } else {
-	return (char *) NULL;
+	return NULL;
     }
 
-    redisplay:
+  redisplay:
     if ((butPtr->tkwin != NULL) && Tk_IsMapped(butPtr->tkwin)
 	    && !(butPtr->flags & REDRAW_PENDING)) {
 	Tcl_DoWhenIdle(TkpDisplayButton, (ClientData) butPtr);
 	butPtr->flags |= REDRAW_PENDING;
     }
-    return (char *) NULL;
+    return NULL;
 }
 
 /*
@@ -1680,52 +1658,51 @@ ButtonVarProc(clientData, interp, name1, name2, flags)
  *
  * ButtonTextVarProc --
  *
- *	This procedure is invoked when someone changes the variable
- *	whose contents are to be displayed in a button.
+ *	This function is invoked when someone changes the variable whose
+ *	contents are to be displayed in a button.
  *
  * Results:
  *	NULL is always returned.
  *
  * Side effects:
- *	The text displayed in the button will change to match the
- *	variable.
+ *	The text displayed in the button will change to match the variable.
  *
  *--------------------------------------------------------------
  */
 
 	/* ARGSUSED */
 static char *
-ButtonTextVarProc(clientData, interp, name1, name2, flags)
-    ClientData clientData;	/* Information about button. */
-    Tcl_Interp *interp;		/* Interpreter containing variable. */
-    CONST char *name1;		/* Not used. */
-    CONST char *name2;		/* Not used. */
-    int flags;			/* Information about what happened. */
+ButtonTextVarProc(
+    ClientData clientData,	/* Information about button. */
+    Tcl_Interp *interp,		/* Interpreter containing variable. */
+    CONST char *name1,		/* Not used. */
+    CONST char *name2,		/* Not used. */
+    int flags)			/* Information about what happened. */
 {
     TkButton *butPtr = (TkButton *) clientData;
     char *name;
     Tcl_Obj *valuePtr;
 
     if (butPtr->flags & BUTTON_DELETED) {
-	return (char *) NULL;
+	return NULL;
     }
 
     name = Tcl_GetString(butPtr->textVarNamePtr);
 
     /*
-     * If the variable is unset, then immediately recreate it unless
-     * the whole interpreter is going away.
+     * If the variable is unset, then immediately recreate it unless the whole
+     * interpreter is going away.
      */
 
     if (flags & TCL_TRACE_UNSETS) {
 	if ((flags & TCL_TRACE_DESTROYED) && !(flags & TCL_INTERP_DESTROYED)) {
-	    Tcl_SetVar2Ex(interp, name, NULL, butPtr->textPtr, 
+	    Tcl_SetVar2Ex(interp, name, NULL, butPtr->textPtr,
 		    TCL_GLOBAL_ONLY);
 	    Tcl_TraceVar(interp, name,
 		    TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
 		    ButtonTextVarProc, clientData);
 	}
-	return (char *) NULL;
+	return NULL;
     }
 
     valuePtr = Tcl_GetVar2Ex(interp, name, NULL, TCL_GLOBAL_ONLY);
@@ -1742,7 +1719,7 @@ ButtonTextVarProc(clientData, interp, name1, name2, flags)
 	Tcl_DoWhenIdle(TkpDisplayButton, (ClientData) butPtr);
 	butPtr->flags |= REDRAW_PENDING;
     }
-    return (char *) NULL;
+    return NULL;
 }
 
 /*
@@ -1750,9 +1727,9 @@ ButtonTextVarProc(clientData, interp, name1, name2, flags)
  *
  * ButtonImageProc --
  *
- *	This procedure is invoked by the image code whenever the manager
- *	for an image does something that affects the size or contents
- *	of an image displayed in a button.
+ *	This function is invoked by the image code whenever the manager for an
+ *	image does something that affects the size or contents of an image
+ *	displayed in a button.
  *
  * Results:
  *	None.
@@ -1764,13 +1741,13 @@ ButtonTextVarProc(clientData, interp, name1, name2, flags)
  */
 
 static void
-ButtonImageProc(clientData, x, y, width, height, imgWidth, imgHeight)
-    ClientData clientData;		/* Pointer to widget record. */
-    int x, y;				/* Upper left pixel (within image)
-					 * that must be redisplayed. */
-    int width, height;			/* Dimensions of area to redisplay
-					 * (may be <= 0). */
-    int imgWidth, imgHeight;		/* New dimensions of image. */
+ButtonImageProc(
+    ClientData clientData,	/* Pointer to widget record. */
+    int x, int y,		/* Upper left pixel (within image) that must
+				 * be redisplayed. */
+    int width, int height,	/* Dimensions of area to redisplay (might be
+				 * <= 0). */
+    int imgWidth, int imgHeight)/* New dimensions of image. */
 {
     register TkButton *butPtr = (TkButton *) clientData;
 
@@ -1788,9 +1765,9 @@ ButtonImageProc(clientData, x, y, width, height, imgWidth, imgHeight)
  *
  * ButtonSelectImageProc --
  *
- *	This procedure is invoked by the image code whenever the manager
- *	for an image does something that affects the size or contents
- *	of the image displayed in a button when it is selected.
+ *	This function is invoked by the image code whenever the manager for an
+ *	image does something that affects the size or contents of the image
+ *	displayed in a button when it is selected.
  *
  * Results:
  *	None.
@@ -1802,18 +1779,18 @@ ButtonImageProc(clientData, x, y, width, height, imgWidth, imgHeight)
  */
 
 static void
-ButtonSelectImageProc(clientData, x, y, width, height, imgWidth, imgHeight)
-    ClientData clientData;		/* Pointer to widget record. */
-    int x, y;				/* Upper left pixel (within image)
-					 * that must be redisplayed. */
-    int width, height;			/* Dimensions of area to redisplay
-					 * (may be <= 0). */
-    int imgWidth, imgHeight;		/* New dimensions of image. */
+ButtonSelectImageProc(
+    ClientData clientData,	/* Pointer to widget record. */
+    int x, int y,		/* Upper left pixel (within image) that must
+				 * be redisplayed. */
+    int width, int height,	/* Dimensions of area to redisplay (might be
+				 * <= 0). */
+    int imgWidth, int imgHeight)/* New dimensions of image. */
 {
     register TkButton *butPtr = (TkButton *) clientData;
 
     /*
-     * Don't recompute geometry:  it's controlled by the primary image.
+     * Don't recompute geometry: it's controlled by the primary image.
      */
 
     if ((butPtr->flags & SELECTED) && (butPtr->tkwin != NULL)
@@ -1829,9 +1806,9 @@ ButtonSelectImageProc(clientData, x, y, width, height, imgWidth, imgHeight)
  *
  * ButtonTristateImageProc --
  *
- *	This procedure is invoked by the image code whenever the manager
- *	for an image does something that affects the size or contents
- *	of the image displayed in a button when it is selected.
+ *	This function is invoked by the image code whenever the manager for an
+ *	image does something that affects the size or contents of the image
+ *	displayed in a button when it is selected.
  *
  * Results:
  *	None.
@@ -1843,18 +1820,18 @@ ButtonSelectImageProc(clientData, x, y, width, height, imgWidth, imgHeight)
  */
 
 static void
-ButtonTristateImageProc(clientData, x, y, width, height, imgWidth, imgHeight)
-    ClientData clientData;		/* Pointer to widget record. */
-    int x, y;				/* Upper left pixel (within image)
-					 * that must be redisplayed. */
-    int width, height;			/* Dimensions of area to redisplay
-					 * (may be <= 0). */
-    int imgWidth, imgHeight;		/* New dimensions of image. */
+ButtonTristateImageProc(
+    ClientData clientData,	/* Pointer to widget record. */
+    int x, int y,		/* Upper left pixel (within image) that must
+				 * be redisplayed. */
+    int width, int height,	/* Dimensions of area to redisplay (might be
+				 * <= 0). */
+    int imgWidth, int imgHeight)/* New dimensions of image. */
 {
     register TkButton *butPtr = (TkButton *) clientData;
 
     /*
-     * Don't recompute geometry:  it's controlled by the primary image.
+     * Don't recompute geometry: it's controlled by the primary image.
      */
 
     if ((butPtr->flags & TRISTATED) && (butPtr->tkwin != NULL)
@@ -1864,3 +1841,11 @@ ButtonTristateImageProc(clientData, x, y, width, height, imgWidth, imgHeight)
 	butPtr->flags |= REDRAW_PENDING;
     }
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/generic/tkCanvas.c b/generic/tkCanvas.c
index 6cc2abf..cb22dca 100644
--- a/generic/tkCanvas.c
+++ b/generic/tkCanvas.c
@@ -12,7 +12,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkCanvas.c,v 1.37 2005/08/18 18:36:11 dkf Exp $
+ * RCS: @(#) $Id: tkCanvas.c,v 1.38 2005/11/04 11:52:50 dkf Exp $
  */
 
 /* #define USE_OLD_TAG_SEARCH 1 */
@@ -121,10 +121,8 @@ static Tk_ConfigSpec configSpecs[] = {
     {TK_CONFIG_BORDER, "-background", "background", "Background",
 	DEF_CANVAS_BG_MONO, Tk_Offset(TkCanvas, bgBorder),
 	TK_CONFIG_MONO_ONLY},
-    {TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL,
-	(char *) NULL, 0, 0},
-    {TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL,
-	(char *) NULL, 0, 0},
+    {TK_CONFIG_SYNONYM, "-bd", "borderWidth", NULL, NULL, 0, 0},
+    {TK_CONFIG_SYNONYM, "-bg", "background", NULL, NULL, 0, 0},
     {TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
 	DEF_CANVAS_BORDER_WIDTH, Tk_Offset(TkCanvas, borderWidth), 0},
     {TK_CONFIG_DOUBLE, "-closeenough", "closeEnough", "CloseEnough",
@@ -205,8 +203,7 @@ static Tk_ConfigSpec configSpecs[] = {
 	"ScrollIncrement",
 	DEF_CANVAS_Y_SCROLL_INCREMENT, Tk_Offset(TkCanvas, yScrollIncrement),
 	0},
-    {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, 0}
+    {TK_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0}
 };
 
 /*
@@ -238,7 +235,7 @@ typedef struct {
 } SearchUids;
 
 static Tcl_ThreadDataKey dataKey;
-static SearchUids *GetStaticUids _ANSI_ARGS_((void));
+static SearchUids *	GetStaticUids(void);
 #endif /* USE_OLD_TAG_SEARCH */
 
 /*
@@ -380,11 +377,11 @@ static Tk_ClassProcs canvasClass = {
  */
 
 int
-Tk_CanvasObjCmd(clientData, interp, argc, argv)
-    ClientData clientData;	/* Main window associated with interpreter. */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int argc;			/* Number of arguments. */
-    Tcl_Obj *CONST argv[];	/* Argument objects. */
+Tk_CanvasObjCmd(
+    ClientData clientData,	/* Main window associated with interpreter. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int argc,			/* Number of arguments. */
+    Tcl_Obj *CONST argv[])	/* Argument objects. */
 {
     Tk_Window tkwin = (Tk_Window) clientData;
     TkCanvas *canvasPtr;
@@ -399,8 +396,7 @@ Tk_CanvasObjCmd(clientData, interp, argc, argv)
 	return TCL_ERROR;
     }
 
-    new = Tk_CreateWindowFromPath(interp, tkwin,
-	    Tcl_GetString(argv[1]), (char *) NULL);
+    new = Tk_CreateWindowFromPath(interp, tkwin, Tcl_GetString(argv[1]), NULL);
     if (new == NULL) {
 	return TCL_ERROR;
     }
@@ -507,7 +503,7 @@ Tk_CanvasObjCmd(clientData, interp, argc, argv)
     Tcl_SetResult(interp, Tk_PathName(canvasPtr->tkwin), TCL_STATIC);
     return TCL_OK;
 
-    error:
+  error:
     Tk_DestroyWindow(canvasPtr->tkwin);
     return TCL_ERROR;
 }
@@ -531,11 +527,11 @@ Tk_CanvasObjCmd(clientData, interp, argc, argv)
  */
 
 static int
-CanvasWidgetCmd(clientData, interp, objc, objv)
-    ClientData clientData;	/* Information about canvas widget. */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+CanvasWidgetCmd(
+    ClientData clientData,	/* Information about canvas widget. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) clientData;
     int c, result;
@@ -677,7 +673,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 
 	    if (object == 0) {
 		Tcl_AppendResult(interp, "item \"", Tcl_GetString(objv[2]),
-			"\" doesn't exist", (char *) NULL);
+			"\" doesn't exist", NULL);
 		result = TCL_ERROR;
 		goto done;
 	    }
@@ -701,7 +697,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 
 	    if (object == 0) {
 		Tcl_AppendResult(interp, "item \"", Tcl_GetString(objv[2]),
-			"\" doesn't exist", (char *) NULL);
+			"\" doesn't exist", NULL);
 		result = TCL_ERROR;
 		goto done;
 	    }
@@ -780,7 +776,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 		Tcl_ResetResult(interp);
 		Tcl_AppendResult(interp, "requested illegal events; ",
 			"only key, button, motion, enter, leave, and virtual ",
-			"events may be used", (char *) NULL);
+			"events may be used", NULL);
 		result = TCL_ERROR;
 		goto done;
 	    }
@@ -882,7 +878,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
     case CANV_CONFIGURE:
 	if (objc == 2) {
 	    result = Tk_ConfigureInfo(interp, canvasPtr->tkwin, configSpecs,
-		    (char *) canvasPtr, (char *) NULL, 0);
+		    (char *) canvasPtr, NULL, 0);
 	} else if (objc == 3) {
 	    result = Tk_ConfigureInfo(interp, canvasPtr->tkwin, configSpecs,
 		    (char *) canvasPtr, Tcl_GetString(objv[2]), 0);
@@ -946,8 +942,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 		    Tcl_MutexUnlock(&typeListMutex);
 		badType:
 		    Tcl_AppendResult(interp,
-			    "unknown or ambiguous item type \"",
-			    arg, "\"", (char *) NULL);
+			    "unknown or ambiguous item type \"",arg,"\"",NULL);
 		    result = TCL_ERROR;
 		    goto done;
 		}
@@ -1169,9 +1164,9 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	    goto done;
 	}
 #ifdef USE_OLD_TAG_SEARCH
-	result = FindItems(interp, canvasPtr, objc, objv, (Tcl_Obj *) NULL, 2);
+	result = FindItems(interp, canvasPtr, objc, objv, NULL, 2);
 #else /* USE_OLD_TAG_SEARCH */
-	result = FindItems(interp, canvasPtr, objc, objv, (Tcl_Obj *) NULL, 2,
+	result = FindItems(interp, canvasPtr, objc, objv, NULL, 2,
 		&searchPtr);
 #endif /* USE_OLD_TAG_SEARCH */
 	break;
@@ -1275,7 +1270,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	}
 	if (itemPtr == NULL) {
 	    Tcl_AppendResult(interp, "can't find an indexable item \"",
-		    Tcl_GetString(objv[2]), "\"", (char *) NULL);
+		    Tcl_GetString(objv[2]), "\"", NULL);
 	    result = TCL_ERROR;
 	    goto done;
 	}
@@ -1369,7 +1364,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	    if (objc == 3) {
 		result = Tk_ConfigureInfo(canvasPtr->interp, canvasPtr->tkwin,
 			itemPtr->typePtr->configSpecs, (char *) itemPtr,
-			(char *) NULL, 0);
+			NULL, 0);
 	    } else if (objc == 4) {
 		result = Tk_ConfigureInfo(canvasPtr->interp, canvasPtr->tkwin,
 			itemPtr->typePtr->configSpecs, (char *) itemPtr,
@@ -1416,7 +1411,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	    FIRST_CANVAS_ITEM_MATCHING(objv[3], &searchPtr, goto done);
 	    if (itemPtr == NULL) {
 		Tcl_AppendResult(interp, "tag \"", Tcl_GetString(objv[3]),
-			"\" doesn't match any items", (char *) NULL);
+			"\" doesn't match any items", NULL);
 		goto done;
 	    }
 	    itemPtr = itemPtr->prevPtr;
@@ -1482,7 +1477,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	    }
 	    if (prevPtr == NULL) {
 		Tcl_AppendResult(interp, "tagOrId \"", Tcl_GetString(objv[3]),
-			"\" doesn't match any items", (char *) NULL);
+			"\" doesn't match any items", NULL);
 		result = TCL_ERROR;
 		goto done;
 	    }
@@ -1593,7 +1588,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	    if (itemPtr == NULL) {
 		Tcl_AppendResult(interp,
 			"can't find an indexable and selectable item \"",
-			Tcl_GetString(objv[3]), "\"", (char *) NULL);
+			Tcl_GetString(objv[3]), "\"", NULL);
 		result = TCL_ERROR;
 		goto done;
 	    }
@@ -1638,7 +1633,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	    break;
 	case CANV_CLEAR:
 	    if (objc != 3) {
-		Tcl_AppendResult(interp, 3, objv, (char *) NULL);
+		Tcl_AppendResult(interp, 3, objv, NULL);
 		result = TCL_ERROR;
 		goto done;
 	    }
@@ -1660,7 +1655,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	    break;
 	case CANV_ITEM:
 	    if (objc != 3) {
-		Tcl_WrongNumArgs(interp, 3, objv, (char *) NULL);
+		Tcl_WrongNumArgs(interp, 3, objv, NULL);
 		result = TCL_ERROR;
 		goto done;
 	    }
@@ -1813,8 +1808,8 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
  */
 
 static void
-DestroyCanvas(memPtr)
-    char *memPtr;		/* Info about canvas widget. */
+DestroyCanvas(
+    char *memPtr)		/* Info about canvas widget. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) memPtr;
     Tk_Item *itemPtr;
@@ -1884,13 +1879,13 @@ DestroyCanvas(memPtr)
  */
 
 static int
-ConfigureCanvas(interp, canvasPtr, objc, objv, flags)
-    Tcl_Interp *interp;		/* Used for error reporting. */
-    TkCanvas *canvasPtr;	/* Information about widget; may or may not
+ConfigureCanvas(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    TkCanvas *canvasPtr,	/* Information about widget; may or may not
 				 * already have values for some fields. */
-    int objc;			/* Number of valid entries in objv. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
-    int flags;			/* Flags to pass to Tk_ConfigureWidget. */
+    int objc,			/* Number of valid entries in objv. */
+    Tcl_Obj *CONST objv[],	/* Argument objects. */
+    int flags)			/* Flags to pass to Tk_ConfigureWidget. */
 {
     XGCValues gcValues;
     GC new;
@@ -1957,7 +1952,7 @@ ConfigureCanvas(interp, canvasPtr, objc, objv, flags)
 	}
 	if (argc2 != 4) {
 	    Tcl_AppendResult(interp, "bad scrollRegion \"",
-		    canvasPtr->regionString, "\"", (char *) NULL);
+		    canvasPtr->regionString, "\"", NULL);
 	    badRegion:
 	    ckfree(canvasPtr->regionString);
 	    ckfree((char *) argv2);
@@ -2028,8 +2023,8 @@ ConfigureCanvas(interp, canvasPtr, objc, objv, flags)
  */
 
 static void
-CanvasWorldChanged(instanceData)
-    ClientData instanceData;	/* Information about widget. */
+CanvasWorldChanged(
+    ClientData instanceData)	/* Information about widget. */
 {
     TkCanvas *canvasPtr;
     Tk_Item *itemPtr;
@@ -2071,8 +2066,8 @@ CanvasWorldChanged(instanceData)
  */
 
 static void
-DisplayCanvas(clientData)
-    ClientData clientData;	/* Information about widget. */
+DisplayCanvas(
+    ClientData clientData)	/* Information about widget. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) clientData;
     Tk_Window tkwin = canvasPtr->tkwin;
@@ -2299,9 +2294,9 @@ DisplayCanvas(clientData)
  */
 
 static void
-CanvasEventProc(clientData, eventPtr)
-    ClientData clientData;	/* Information about window. */
-    XEvent *eventPtr;		/* Information about event. */
+CanvasEventProc(
+    ClientData clientData,	/* Information about window. */
+    XEvent *eventPtr)		/* Information about event. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) clientData;
 
@@ -2392,8 +2387,8 @@ CanvasEventProc(clientData, eventPtr)
  */
 
 static void
-CanvasCmdDeletedProc(clientData)
-    ClientData clientData;	/* Pointer to widget record for widget. */
+CanvasCmdDeletedProc(
+    ClientData clientData)	/* Pointer to widget record for widget. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) clientData;
     Tk_Window tkwin = canvasPtr->tkwin;
@@ -2429,11 +2424,11 @@ CanvasCmdDeletedProc(clientData)
  */
 
 void
-Tk_CanvasEventuallyRedraw(canvas, x1, y1, x2, y2)
-    Tk_Canvas canvas;		/* Information about widget. */
-    int x1, y1;			/* Upper left corner of area to redraw.
-				 * Pixels on edge are redrawn. */
-    int x2, y2;			/* Lower right corner of area to redraw.
+Tk_CanvasEventuallyRedraw(
+    Tk_Canvas canvas,		/* Information about widget. */
+    int x1, int y1,		/* Upper left corner of area to redraw. Pixels
+				 * on edge are redrawn. */
+    int x2, int y2)		/* Lower right corner of area to redraw.
 				 * Pixels on edge are not redrawn. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) canvas;
@@ -2497,9 +2492,9 @@ Tk_CanvasEventuallyRedraw(canvas, x1, y1, x2, y2)
  */
 
 static void
-EventuallyRedrawItem(canvas, itemPtr)
-    Tk_Canvas canvas;		/* Information about widget. */
-    Tk_Item *itemPtr;		/* Item to be redrawn. */
+EventuallyRedrawItem(
+    Tk_Canvas canvas,		/* Information about widget. */
+    Tk_Item *itemPtr)		/* Item to be redrawn. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) canvas;
     if ((itemPtr->x1 >= itemPtr->x2) || (itemPtr->y1 >= itemPtr->y2) ||
@@ -2561,8 +2556,8 @@ EventuallyRedrawItem(canvas, itemPtr)
  */
 
 void
-Tk_CreateItemType(typePtr)
-    Tk_ItemType *typePtr;	/* Information about item type; storage must
+Tk_CreateItemType(
+    Tk_ItemType *typePtr)	/* Information about item type; storage must
 				 * be statically allocated (must live
 				 * forever). */
 {
@@ -2614,7 +2609,7 @@ Tk_CreateItemType(typePtr)
  */
 
 Tk_ItemType *
-Tk_GetItemTypes()
+Tk_GetItemTypes(void)
 {
     if (typeList == NULL) {
 	InitCanvas();
@@ -2640,7 +2635,7 @@ Tk_GetItemTypes()
  */
 
 static void
-InitCanvas()
+InitCanvas(void)
 {
     Tcl_MutexLock(&typeListMutex);
     if (typeList != NULL) {
@@ -2685,10 +2680,10 @@ InitCanvas()
  */
 
 static Tk_Item *
-StartTagSearch(canvasPtr, tagObj, searchPtr)
-    TkCanvas *canvasPtr;	/* Canvas whose items are to be searched. */
-    Tcl_Obj *tagObj;		/* Object giving tag value. */
-    TagSearch *searchPtr;	/* Record describing tag search; will be
+StartTagSearch(
+    TkCanvas *canvasPtr,	/* Canvas whose items are to be searched. */
+    Tcl_Obj *tagObj,		/* Object giving tag value. */
+    TagSearch *searchPtr)	/* Record describing tag search; will be
 				 * initialized here. */
 {
     int id;
@@ -2799,8 +2794,8 @@ StartTagSearch(canvasPtr, tagObj, searchPtr)
  */
 
 static Tk_Item *
-NextItem(searchPtr)
-    TagSearch *searchPtr;	/* Record describing search in progress. */
+NextItem(
+    TagSearch *searchPtr)	/* Record describing search in progress. */
 {
     Tk_Item *itemPtr, *lastPtr;
     int count;
@@ -2885,7 +2880,7 @@ NextItem(searchPtr)
  */
 
 static SearchUids *
-GetStaticUids()
+GetStaticUids(void)
 {
     SearchUids *searchUids = (SearchUids *)
 	    Tcl_GetThreadData(&dataKey, sizeof(SearchUids));
@@ -2920,8 +2915,8 @@ GetStaticUids()
  */
 
 static void
-TagSearchExprInit(exprPtrPtr)
-TagSearchExpr **exprPtrPtr;
+TagSearchExprInit(
+    TagSearchExpr **exprPtrPtr)
 {
     TagSearchExpr* expr = *exprPtrPtr;
 
@@ -2952,8 +2947,8 @@ TagSearchExpr **exprPtrPtr;
  */
 
 static void
-TagSearchExprDestroy(expr)
-    TagSearchExpr *expr;
+TagSearchExprDestroy(
+    TagSearchExpr *expr)
 {
     if (expr) {
     	if (expr->uids) {
@@ -2986,10 +2981,10 @@ TagSearchExprDestroy(expr)
  */
 
 static int
-TagSearchScan(canvasPtr, tagObj, searchPtrPtr)
-    TkCanvas *canvasPtr;	/* Canvas whose items are to be searched. */
-    Tcl_Obj *tagObj;		/* Object giving tag value. */
-    TagSearch **searchPtrPtr;	/* Record describing tag search; will be
+TagSearchScan(
+    TkCanvas *canvasPtr,	/* Canvas whose items are to be searched. */
+    Tcl_Obj *tagObj,		/* Object giving tag value. */
+    TagSearch **searchPtrPtr)	/* Record describing tag search; will be
 				 * initialized here. */
 {
     char *tag = Tcl_GetString(tagObj);
@@ -3155,8 +3150,8 @@ TagSearchScan(canvasPtr, tagObj, searchPtrPtr)
  */
 
 static void
-TagSearchDestroy(searchPtr)
-    TagSearch *searchPtr;	/* Record describing tag search */
+TagSearchDestroy(
+    TagSearch *searchPtr)	/* Record describing tag search */
 {
     if (searchPtr) {
 	TagSearchExprDestroy(searchPtr->expr);
@@ -3185,10 +3180,10 @@ TagSearchDestroy(searchPtr)
  */
 
 static int
-TagSearchScanExpr(interp, searchPtr, expr)
-    Tcl_Interp *interp;		/* Current interpreter. */
-    TagSearch *searchPtr;	/* Search data */
-    TagSearchExpr *expr;	/* compiled expression result */
+TagSearchScanExpr(
+    Tcl_Interp *interp,		/* Current interpreter. */
+    TagSearch *searchPtr,	/* Search data */
+    TagSearchExpr *expr)	/* compiled expression result */
 {
     int looking_for_tag;	/* When true, scanner expects next char(s) to
 				 * be a tag, else operand expected */
@@ -3232,7 +3227,7 @@ TagSearchScanExpr(interp, searchPtr, expr)
 		if (looking_for_tag > 1) {
 		    Tcl_AppendResult(interp,
 			    "Too many '!' in tag search expression",
-			    (char *) NULL);
+			    NULL);
 		    return TCL_ERROR;
 		}
 		looking_for_tag++;
@@ -3281,13 +3276,13 @@ TagSearchScanExpr(interp, searchPtr, expr)
 		if (! found_endquote) {
 		    Tcl_AppendResult(interp,
 			    "Missing endquote in tag search expression",
-			    (char *) NULL);
+			    NULL);
 		    return TCL_ERROR;
 		}
 		if (! (tag - searchPtr->rewritebuffer)) {
 		    Tcl_AppendResult(interp,
 			    "Null quoted tag string in tag search expression",
-			    (char *) NULL);
+			    NULL);
 		    return TCL_ERROR;
 		}
 		*tag++ = '\0';
@@ -3303,7 +3298,7 @@ TagSearchScanExpr(interp, searchPtr, expr)
 	    case ')':
 		Tcl_AppendResult(interp,
 			"Unexpected operator in tag search expression",
-			(char *) NULL);
+			NULL);
 		return TCL_ERROR;
 
 	    default:	/* unquoted tag string */
@@ -3366,7 +3361,7 @@ TagSearchScanExpr(interp, searchPtr, expr)
 		if (c != '&') {
 		    Tcl_AppendResult(interp,
 			    "Singleton '&' in tag search expression",
-			    (char *) NULL);
+			    NULL);
 		    return TCL_ERROR;
 		}
 		expr->uids[expr->index++] = searchUids->andUid;
@@ -3378,7 +3373,7 @@ TagSearchScanExpr(interp, searchPtr, expr)
 		if (c != '|') {
 		    Tcl_AppendResult(interp,
 			    "Singleton '|' in tag search expression",
-			    (char *) NULL);
+			    NULL);
 		    return TCL_ERROR;
 		}
 		expr->uids[expr->index++] = searchUids->orUid;
@@ -3397,7 +3392,7 @@ TagSearchScanExpr(interp, searchPtr, expr)
 	    default:	/* syntax error */
 		Tcl_AppendResult(interp,
 			"Invalid boolean operator in tag search expression",
-			(char *) NULL);
+			NULL);
 		return TCL_ERROR;
 	    }
 	}
@@ -3407,8 +3402,7 @@ TagSearchScanExpr(interp, searchPtr, expr)
     if (found_tag && ! looking_for_tag) {
 	return TCL_OK;
     }
-    Tcl_AppendResult(interp, "Missing tag in tag search expression",
-	    (char *) NULL);
+    Tcl_AppendResult(interp, "Missing tag in tag search expression", NULL);
     return TCL_ERROR;
 }
 
@@ -3429,9 +3423,9 @@ TagSearchScanExpr(interp, searchPtr, expr)
  */
 
 static int
-TagSearchEvalExpr(expr, itemPtr)
-    TagSearchExpr *expr;	/* Search expression */
-    Tk_Item *itemPtr;		/* Item being test for match */
+TagSearchEvalExpr(
+    TagSearchExpr *expr,	/* Search expression */
+    Tk_Item *itemPtr)		/* Item being test for match */
 {
     int looking_for_tag;	/* When true, scanner expects next char(s) to
 				 * be a tag, else operand expected. */
@@ -3594,8 +3588,8 @@ TagSearchEvalExpr(expr, itemPtr)
  */
 
 static Tk_Item *
-TagSearchFirst(searchPtr)
-    TagSearch *searchPtr;	/* Record describing tag search */
+TagSearchFirst(
+    TagSearch *searchPtr)	/* Record describing tag search */
 {
     Tk_Item *itemPtr, *lastPtr;
     Tk_Uid uid, *tagPtr;
@@ -3709,8 +3703,8 @@ TagSearchFirst(searchPtr)
  */
 
 static Tk_Item *
-TagSearchNext(searchPtr)
-    TagSearch *searchPtr;	/* Record describing search in progress. */
+TagSearchNext(
+    TagSearch *searchPtr)	/* Record describing search in progress. */
 {
     Tk_Item *itemPtr, *lastPtr;
     Tk_Uid uid, *tagPtr;
@@ -3812,11 +3806,11 @@ TagSearchNext(searchPtr)
  */
 
 static void
-DoItem(interp, itemPtr, tag)
-    Tcl_Interp *interp;		/* Interpreter in which to (possibly) record
+DoItem(
+    Tcl_Interp *interp,		/* Interpreter in which to (possibly) record
 				 * item id. */
-    Tk_Item *itemPtr;		/* Item to (possibly) modify. */
-    Tk_Uid tag;			/* Tag to add to those already present for
+    Tk_Item *itemPtr,		/* Item to (possibly) modify. */
+    Tk_Uid tag)			/* Tag to add to those already present for
 				 * item, or NULL. */
 {
     Tk_Uid *tagPtr;
@@ -3892,28 +3886,25 @@ DoItem(interp, itemPtr, tag)
  */
 
 static int
-#ifdef USE_OLD_TAG_SEARCH
-FindItems(interp, canvasPtr, objc, objv, newTag, first)
-#else /* USE_OLD_TAG_SEARCH */
-FindItems(interp, canvasPtr, objc, objv, newTag, first, searchPtrPtr)
-#endif /* USE_OLD_TAG_SEARCH */
-    Tcl_Interp *interp;		/* Interpreter for error reporting. */
-    TkCanvas *canvasPtr;	/* Canvas whose items are to be searched. */
-    int objc;			/* Number of entries in argv. Must be greater
+FindItems(
+    Tcl_Interp *interp,		/* Interpreter for error reporting. */
+    TkCanvas *canvasPtr,	/* Canvas whose items are to be searched. */
+    int objc,			/* Number of entries in argv. Must be greater
 				 * than zero. */
-    Tcl_Obj *CONST *objv;	/* Arguments that describe what items to
+    Tcl_Obj *CONST *objv,	/* Arguments that describe what items to
 				 * search for (see user doc on "find" and
 				 * "addtag" options). */
-    Tcl_Obj *newTag;		/* If non-NULL, gives new tag to set on all
+    Tcl_Obj *newTag,		/* If non-NULL, gives new tag to set on all
 				 * found items; if NULL, then ids of found
 				 * items are returned in the interp's
 				 * result. */
-    int first;			/* For error messages: gives number of
+    int first			/* For error messages: gives number of
 				 * elements of objv which are already
 				 * handled. */
 #ifndef USE_OLD_TAG_SEARCH
-    TagSearch **searchPtrPtr;	/* From CanvasWidgetCmd local vars*/
+    ,TagSearch **searchPtrPtr	/* From CanvasWidgetCmd local vars*/
 #endif /* not USE_OLD_TAG_SEARCH */
+    )
 {
 #ifdef USE_OLD_TAG_SEARCH
     TagSearch search;
@@ -3958,7 +3949,7 @@ FindItems(interp, canvasPtr, objc, objv, newTag, first, searchPtrPtr)
     }
     case CANV_ALL:
 	if (objc != first+1) {
-	    Tcl_WrongNumArgs(interp, first+1, objv, (char *) NULL);
+	    Tcl_WrongNumArgs(interp, first+1, objv, NULL);
 	    return TCL_ERROR;
 	}
 
@@ -4003,7 +3994,7 @@ FindItems(interp, canvasPtr, objc, objv, newTag, first, searchPtrPtr)
 	    }
 	    if (halo < 0.0) {
 		Tcl_AppendResult(interp, "can't have negative halo value \"",
-			Tcl_GetString(objv[3]), "\"", (char *) NULL);
+			Tcl_GetString(objv[3]), "\"", NULL);
 		return TCL_ERROR;
 	    }
 	} else {
@@ -4144,18 +4135,18 @@ FindItems(interp, canvasPtr, objc, objv, newTag, first, searchPtrPtr)
  */
 
 static int
-FindArea(interp, canvasPtr, objv, uid, enclosed)
-    Tcl_Interp *interp;		/* Interpreter for error reporting and result
+FindArea(
+    Tcl_Interp *interp,		/* Interpreter for error reporting and result
 				 * storing. */
-    TkCanvas *canvasPtr;	/* Canvas whose items are to be searched. */
-    Tcl_Obj *CONST *objv;	/* Array of four arguments that give the
+    TkCanvas *canvasPtr,	/* Canvas whose items are to be searched. */
+    Tcl_Obj *CONST *objv,	/* Array of four arguments that give the
 				 * coordinates of the rectangular area to
 				 * search. */
-    Tk_Uid uid;			/* If non-NULL, gives new tag to set on all
+    Tk_Uid uid,			/* If non-NULL, gives new tag to set on all
 				 * found items; if NULL, then ids of found
 				 * items are returned in the interp's
 				 * result. */
-    int enclosed;		/* 0 means overlapping or enclosed items are
+    int enclosed)		/* 0 means overlapping or enclosed items are
 				 * OK, 1 means only enclosed items are OK. */
 {
     double rect[4], tmp;
@@ -4227,20 +4218,24 @@ FindArea(interp, canvasPtr, objv, uid, enclosed)
 
 #ifdef USE_OLD_TAG_SEARCH
 static void
-RelinkItems(canvasPtr, tag, prevPtr)
+RelinkItems(
+    TkCanvas *canvasPtr,	/* Canvas to be modified. */
+    Tcl_Obj *tag,		/* Tag identifying items to be moved in the
+				 * redisplay list. */
+    Tk_Item *prevPtr)		/* Reposition the items so that they go just
+				 * after this item (NULL means put at
+				 * beginning of list). */
 #else /* USE_OLD_TAG_SEARCH */
 static int
-RelinkItems(canvasPtr, tag, prevPtr, searchPtrPtr)
-#endif /* USE_OLD_TAG_SEARCH */
-    TkCanvas *canvasPtr;	/* Canvas to be modified. */
-    Tcl_Obj *tag;		/* Tag identifying items to be moved in the
+RelinkItems(
+    TkCanvas *canvasPtr,	/* Canvas to be modified. */
+    Tcl_Obj *tag,		/* Tag identifying items to be moved in the
 				 * redisplay list. */
-    Tk_Item *prevPtr;		/* Reposition the items so that they go just
+    Tk_Item *prevPtr,		/* Reposition the items so that they go just
 				 * after this item (NULL means put at
 				 * beginning of list). */
-#ifndef USE_OLD_TAG_SEARCH
-    TagSearch **searchPtrPtr;   /* From CanvasWidgetCmd local vars */
-#endif /* not USE_OLD_TAG_SEARCH */
+    TagSearch **searchPtrPtr)	/* From CanvasWidgetCmd local vars */
+#endif /* USE_OLD_TAG_SEARCH */
 {
     Tk_Item *itemPtr;
 #ifdef USE_OLD_TAG_SEARCH
@@ -4346,9 +4341,9 @@ RelinkItems(canvasPtr, tag, prevPtr, searchPtrPtr)
  */
 
 static void
-CanvasBindProc(clientData, eventPtr)
-    ClientData clientData;	/* Pointer to canvas structure. */
-    XEvent *eventPtr;		/* Pointer to X event that just happened. */
+CanvasBindProc(
+    ClientData clientData,	/* Pointer to canvas structure. */
+    XEvent *eventPtr)		/* Pointer to X event that just happened. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) clientData;
 
@@ -4428,7 +4423,7 @@ CanvasBindProc(clientData, eventPtr)
     }
     CanvasDoEvent(canvasPtr, eventPtr);
 
-    done:
+  done:
     Tcl_Release((ClientData) canvasPtr);
 }
 
@@ -4456,10 +4451,10 @@ CanvasBindProc(clientData, eventPtr)
  */
 
 static void
-PickCurrentItem(canvasPtr, eventPtr)
-    TkCanvas *canvasPtr;	/* Canvas widget in which to select current
+PickCurrentItem(
+    TkCanvas *canvasPtr,	/* Canvas widget in which to select current
 				 * item. */
-    XEvent *eventPtr;		/* Event describing location of mouse cursor.
+    XEvent *eventPtr)		/* Event describing location of mouse cursor.
 				 * Must be EnterWindow, LeaveWindow,
 				 * ButtonRelease, or MotionNotify. */
 {
@@ -4627,23 +4622,21 @@ PickCurrentItem(canvasPtr, eventPtr)
 	    (prevItemPtr->redraw_flags & TK_ITEM_STATE_DEPENDANT)) {
 	EventuallyRedrawItem((Tk_Canvas) canvasPtr, prevItemPtr);
 	(*prevItemPtr->typePtr->configProc)(canvasPtr->interp,
-		(Tk_Canvas) canvasPtr, prevItemPtr, 0, (Tcl_Obj **) NULL,
+		(Tk_Canvas) canvasPtr, prevItemPtr, 0, NULL,
 		TK_CONFIG_ARGV_ONLY);
     }
     if (canvasPtr->currentItemPtr != NULL) {
 	XEvent event;
 
 #ifdef USE_OLD_TAG_SEARCH
-	DoItem((Tcl_Interp *) NULL, canvasPtr->currentItemPtr,
-		Tk_GetUid("current"));
+	DoItem(NULL, canvasPtr->currentItemPtr, Tk_GetUid("current"));
 #else /* USE_OLD_TAG_SEARCH */
-	DoItem((Tcl_Interp *) NULL, canvasPtr->currentItemPtr,
-		searchUids->currentUid);
+	DoItem(NULL, canvasPtr->currentItemPtr, searchUids->currentUid);
 #endif /* USE_OLD_TAG_SEA */
 	if ((canvasPtr->currentItemPtr->redraw_flags & TK_ITEM_STATE_DEPENDANT &&
 		prevItemPtr != canvasPtr->currentItemPtr)) {
 	    (*canvasPtr->currentItemPtr->typePtr->configProc)(canvasPtr->interp,
-		    (Tk_Canvas) canvasPtr, canvasPtr->currentItemPtr, 0, (Tcl_Obj **) NULL,
+		    (Tk_Canvas) canvasPtr, canvasPtr->currentItemPtr, 0, NULL,
 		    TK_CONFIG_ARGV_ONLY);
 	    EventuallyRedrawItem((Tk_Canvas) canvasPtr,
 		    canvasPtr->currentItemPtr);
@@ -4675,9 +4668,9 @@ PickCurrentItem(canvasPtr, eventPtr)
  */
 
 static Tk_Item *
-CanvasFindClosest(canvasPtr, coords)
-    TkCanvas *canvasPtr;	/* Canvas widget to search. */
-    double coords[2];		/* Desired x,y position in canvas, not screen,
+CanvasFindClosest(
+    TkCanvas *canvasPtr,	/* Canvas widget to search. */
+    double coords[2])		/* Desired x,y position in canvas, not screen,
 				 * coordinates.) */
 {
     Tk_Item *itemPtr;
@@ -4729,9 +4722,9 @@ CanvasFindClosest(canvasPtr, coords)
  */
 
 static void
-CanvasDoEvent(canvasPtr, eventPtr)
-    TkCanvas *canvasPtr;	/* Canvas widget in which event occurred. */
-    XEvent *eventPtr;		/* Real or simulated X event that is to be
+CanvasDoEvent(
+    TkCanvas *canvasPtr,	/* Canvas widget in which event occurred. */
+    XEvent *eventPtr)		/* Real or simulated X event that is to be
 				 * processed. */
 {
 #define NUM_STATIC 3
@@ -4860,8 +4853,8 @@ CanvasDoEvent(canvasPtr, eventPtr)
  */
 
 static void
-CanvasBlinkProc(clientData)
-    ClientData clientData;	/* Pointer to record describing entry. */
+CanvasBlinkProc(
+    ClientData clientData)	/* Pointer to record describing entry. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) clientData;
 
@@ -4904,9 +4897,9 @@ CanvasBlinkProc(clientData)
  */
 
 static void
-CanvasFocusProc(canvasPtr, gotFocus)
-    TkCanvas *canvasPtr;	/* Canvas that just got or lost focus. */
-    int gotFocus;		/* 1 means window is getting focus, 0 means
+CanvasFocusProc(
+    TkCanvas *canvasPtr,	/* Canvas that just got or lost focus. */
+    int gotFocus)		/* 1 means window is getting focus, 0 means
 				 * it's losing it. */
 {
     Tcl_DeleteTimerHandler(canvasPtr->insertBlinkHandler);
@@ -4954,10 +4947,10 @@ CanvasFocusProc(canvasPtr, gotFocus)
  */
 
 static void
-CanvasSelectTo(canvasPtr, itemPtr, index)
-    TkCanvas *canvasPtr;	/* Information about widget. */
-    Tk_Item *itemPtr;		/* Item that is to hold selection. */
-    int index;			/* Index of element that is to become the
+CanvasSelectTo(
+    TkCanvas *canvasPtr,	/* Information about widget. */
+    Tk_Item *itemPtr,		/* Item that is to hold selection. */
+    int index)			/* Index of element that is to become the
 				 * "other" end of the selection. */
 {
     int oldFirst, oldLast;
@@ -5020,12 +5013,12 @@ CanvasSelectTo(canvasPtr, itemPtr, index)
  */
 
 static int
-CanvasFetchSelection(clientData, offset, buffer, maxBytes)
-    ClientData clientData;	/* Information about canvas widget. */
-    int offset;			/* Offset within selection of first character
+CanvasFetchSelection(
+    ClientData clientData,	/* Information about canvas widget. */
+    int offset,			/* Offset within selection of first character
 				 * to be returned. */
-    char *buffer;		/* Location in which to place selection. */
-    int maxBytes;		/* Maximum number of bytes to place at buffer,
+    char *buffer,		/* Location in which to place selection. */
+    int maxBytes)		/* Maximum number of bytes to place at buffer,
 				 * not including terminating NULL
 				 * character. */
 {
@@ -5061,8 +5054,8 @@ CanvasFetchSelection(clientData, offset, buffer, maxBytes)
  */
 
 static void
-CanvasLostSelection(clientData)
-    ClientData clientData;	/* Information about entry widget. */
+CanvasLostSelection(
+    ClientData clientData)	/* Information about entry widget. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) clientData;
 
@@ -5091,9 +5084,9 @@ CanvasLostSelection(clientData)
  */
 
 static double
-GridAlign(coord, spacing)
-    double coord;		/* Coordinate to grid-align. */
-    double spacing;		/* Spacing between grid lines. If <= 0 then no
+GridAlign(
+    double coord,		/* Coordinate to grid-align. */
+    double spacing)		/* Spacing between grid lines. If <= 0 then no
 				 * alignment is done. */
 {
     if (spacing <= 0.0) {
@@ -5126,11 +5119,11 @@ GridAlign(coord, spacing)
  */
 
 static Tcl_Obj *
-ScrollFractions(screen1, screen2, object1, object2)
-    int screen1;		/* Lowest coordinate visible in the window. */
-    int screen2;		/* Highest coordinate visible in the window. */
-    int object1;		/* Lowest coordinate in the object. */
-    int object2;		/* Highest coordinate in the object. */
+ScrollFractions(
+    int screen1,		/* Lowest coordinate visible in the window. */
+    int screen2,		/* Highest coordinate visible in the window. */
+    int object1,		/* Lowest coordinate in the object. */
+    int object2)		/* Highest coordinate in the object. */
 {
     Tcl_Obj *buffer[2];
     double range, f1, f2;
@@ -5178,8 +5171,8 @@ ScrollFractions(screen1, screen2, object1, object2)
  */
 
 static void
-CanvasUpdateScrollbars(canvasPtr)
-    TkCanvas *canvasPtr;		/* Information about canvas. */
+CanvasUpdateScrollbars(
+    TkCanvas *canvasPtr)		/* Information about canvas. */
 {
     int result;
     Tcl_Interp *interp;
@@ -5195,11 +5188,11 @@ CanvasUpdateScrollbars(canvasPtr)
     interp = canvasPtr->interp;
     Tcl_Preserve((ClientData) interp);
     xScrollCmd = canvasPtr->xScrollCmd;
-    if (xScrollCmd != (char *) NULL) {
+    if (xScrollCmd != NULL) {
 	Tcl_Preserve((ClientData) xScrollCmd);
     }
     yScrollCmd = canvasPtr->yScrollCmd;
-    if (yScrollCmd != (char *) NULL) {
+    if (yScrollCmd != NULL) {
 	Tcl_Preserve((ClientData) yScrollCmd);
     }
     xOrigin = canvasPtr->xOrigin;
@@ -5216,7 +5209,7 @@ CanvasUpdateScrollbars(canvasPtr)
 	Tcl_Obj *fractions = ScrollFractions(xOrigin + inset,
 		xOrigin + width - inset, scrollX1, scrollX2);
 	result = Tcl_VarEval(interp, xScrollCmd, " ", Tcl_GetString(fractions),
-		(char *) NULL);
+		NULL);
 	Tcl_DecrRefCount(fractions);
 	if (result != TCL_OK) {
 	    Tcl_BackgroundError(interp);
@@ -5229,7 +5222,7 @@ CanvasUpdateScrollbars(canvasPtr)
 	Tcl_Obj *fractions = ScrollFractions(yOrigin + inset,
 		yOrigin + height - inset, scrollY1, scrollY2);
 	result = Tcl_VarEval(interp, yScrollCmd, " ", Tcl_GetString(fractions),
-		(char *) NULL);
+		NULL);
 	Tcl_DecrRefCount(fractions);
 	if (result != TCL_OK) {
 	    Tcl_BackgroundError(interp);
@@ -5259,12 +5252,12 @@ CanvasUpdateScrollbars(canvasPtr)
  */
 
 static void
-CanvasSetOrigin(canvasPtr, xOrigin, yOrigin)
-    TkCanvas *canvasPtr;	/* Information about canvas. */
-    int xOrigin;		/* New X origin for canvas (canvas x-coord
+CanvasSetOrigin(
+    TkCanvas *canvasPtr,	/* Information about canvas. */
+    int xOrigin,		/* New X origin for canvas (canvas x-coord
 				 * corresponding to left edge of canvas
 				 * window). */
-    int yOrigin;		/* New Y origin for canvas (canvas y-coord
+    int yOrigin)		/* New Y origin for canvas (canvas y-coord
 				 * corresponding to top edge of canvas
 				 * window). */
 {
@@ -5369,7 +5362,7 @@ CanvasSetOrigin(canvasPtr, xOrigin, yOrigin)
 	    canvasPtr->xOrigin + Tk_Width(canvasPtr->tkwin),
 	    canvasPtr->yOrigin + Tk_Height(canvasPtr->tkwin));
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -5387,9 +5380,9 @@ CanvasSetOrigin(canvasPtr, xOrigin, yOrigin)
 
 /* ARGSUSED */
 static CONST char **
-TkGetStringsFromObjs(objc, objv)
-    int objc;
-    Tcl_Obj *CONST objv[];
+TkGetStringsFromObjs(
+    int objc,
+    Tcl_Obj *CONST objv[])
 {
     register int i;
     CONST char **argv;
@@ -5426,11 +5419,11 @@ TkGetStringsFromObjs(objc, objv)
  */
 
 int
-Tk_CanvasPsColor(interp, canvas, colorPtr)
-    Tcl_Interp *interp;		/* Interpreter for returning Postscript or
+Tk_CanvasPsColor(
+    Tcl_Interp *interp,		/* Interpreter for returning Postscript or
 				 * error message. */
-    Tk_Canvas canvas;		/* Information about canvas. */
-    XColor *colorPtr;		/* Information about color. */
+    Tk_Canvas canvas,		/* Information about canvas. */
+    XColor *colorPtr)		/* Information about color. */
 {
     return Tk_PostscriptColor(interp, ((TkCanvas *) canvas)->psInfo,
 	    colorPtr);
@@ -5459,11 +5452,11 @@ Tk_CanvasPsColor(interp, canvas, colorPtr)
  */
 
 int
-Tk_CanvasPsFont(interp, canvas, tkfont)
-    Tcl_Interp *interp;		/* Interpreter for returning Postscript or
+Tk_CanvasPsFont(
+    Tcl_Interp *interp,		/* Interpreter for returning Postscript or
 				 * error message. */
-    Tk_Canvas canvas;		/* Information about canvas. */
-    Tk_Font tkfont;		/* Information about font in which text is to
+    Tk_Canvas canvas,		/* Information about canvas. */
+    Tk_Font tkfont)		/* Information about font in which text is to
 				 * be printed. */
 {
     return Tk_PostscriptFont(interp, ((TkCanvas *) canvas)->psInfo, tkfont);
@@ -5490,14 +5483,14 @@ Tk_CanvasPsFont(interp, canvas, tkfont)
  */
 
 int
-Tk_CanvasPsBitmap(interp, canvas, bitmap, startX, startY, width, height)
-    Tcl_Interp *interp;		/* Interpreter for returning Postscript or
+Tk_CanvasPsBitmap(
+    Tcl_Interp *interp,		/* Interpreter for returning Postscript or
 				 * error message. */
-    Tk_Canvas canvas;		/* Information about canvas. */
-    Pixmap bitmap;		/* Bitmap for which to generate Postscript. */
-    int startX, startY;		/* Coordinates of upper-left corner of
+    Tk_Canvas canvas,		/* Information about canvas. */
+    Pixmap bitmap,		/* Bitmap for which to generate Postscript. */
+    int startX, int startY,	/* Coordinates of upper-left corner of
 				 * rectangular region to output. */
-    int width, height;		/* Height of rectangular region. */
+    int width, int height)	/* Size of rectangular region. */
 {
     return Tk_PostscriptBitmap(interp, ((TkCanvas *) canvas)->tkwin,
 	    ((TkCanvas *) canvas)->psInfo, bitmap, startX, startY,
@@ -5527,11 +5520,11 @@ Tk_CanvasPsBitmap(interp, canvas, bitmap, startX, startY, width, height)
  */
 
 int
-Tk_CanvasPsStipple(interp, canvas, bitmap)
-    Tcl_Interp *interp;		/* Interpreter for returning Postscript or
+Tk_CanvasPsStipple(
+    Tcl_Interp *interp,		/* Interpreter for returning Postscript or
 				 * error message. */
-    Tk_Canvas canvas;		/* Information about canvas. */
-    Pixmap bitmap;		/* Bitmap to use for stippling. */
+    Tk_Canvas canvas,		/* Information about canvas. */
+    Pixmap bitmap)		/* Bitmap to use for stippling. */
 {
     return Tk_PostscriptStipple(interp, ((TkCanvas *) canvas)->tkwin,
 	    ((TkCanvas *) canvas)->psInfo, bitmap);
@@ -5555,10 +5548,10 @@ Tk_CanvasPsStipple(interp, canvas, bitmap)
  */
 
 double
-Tk_CanvasPsY(canvas, y)
-    Tk_Canvas canvas;		/* Token for canvas on whose behalf Postscript
+Tk_CanvasPsY(
+    Tk_Canvas canvas,		/* Token for canvas on whose behalf Postscript
 				 * is being generated. */
-    double y;			/* Y-coordinate in canvas coords. */
+    double y)			/* Y-coordinate in canvas coords. */
 {
     return Tk_PostscriptY(y, ((TkCanvas *) canvas)->psInfo);
 }
@@ -5581,14 +5574,14 @@ Tk_CanvasPsY(canvas, y)
  */
 
 void
-Tk_CanvasPsPath(interp, canvas, coordPtr, numPoints)
-    Tcl_Interp *interp;		/* Put generated Postscript in this
+Tk_CanvasPsPath(
+    Tcl_Interp *interp,		/* Put generated Postscript in this
 				 * interpreter's result field. */
-    Tk_Canvas canvas;		/* Canvas on whose behalf Postscript is being
+    Tk_Canvas canvas,		/* Canvas on whose behalf Postscript is being
 				 * generated. */
-    double *coordPtr;		/* Pointer to first in array of 2*numPoints
+    double *coordPtr,		/* Pointer to first in array of 2*numPoints
 				 * coordinates giving points for path. */
-    int numPoints;		/* Number of points at *coordPtr. */
+    int numPoints)		/* Number of points at *coordPtr. */
 {
     Tk_PostscriptPath(interp, ((TkCanvas *) canvas)->psInfo,
 	    coordPtr, numPoints);
diff --git a/generic/tkColor.c b/generic/tkColor.c
index 4aa82bb..2390cb7 100644
--- a/generic/tkColor.c
+++ b/generic/tkColor.c
@@ -1,23 +1,23 @@
-/* 
+/*
  * tkColor.c --
  *
- *	This file maintains a database of color values for the Tk
- *	toolkit, in order to avoid round-trips to the server to
- *	map color names to pixel values.
+ *	This file maintains a database of color values for the Tk toolkit, in
+ *	order to avoid round-trips to the server to map color names to pixel
+ *	values.
  *
  * 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: tkColor.c,v 1.10 2004/01/13 02:06:00 davygrvy Exp $
+ * RCS: @(#) $Id: tkColor.c,v 1.11 2005/11/04 11:52:50 dkf Exp $
  */
 
 #include "tkColor.h"
 
 /*
- * Structures of the following following type are used as keys for 
+ * Structures of the following following type are used as keys for
  * colorValueTable (in TkDisplay).
  */
 
@@ -30,28 +30,27 @@ typedef struct {
 
 
 /*
- * The structure below is used to allocate thread-local data. 
+ * The structure below is used to allocate thread-local data.
  */
 
 typedef struct ThreadSpecificData {
-    char rgbString[20];            /* */
+    char rgbString[20];		/* */
 } ThreadSpecificData;
 static Tcl_ThreadDataKey dataKey;
 
 /*
- * Forward declarations for procedures defined in this file:
+ * Forward declarations for functions defined in this file:
  */
 
-static void		ColorInit _ANSI_ARGS_((TkDisplay *dispPtr));
-static void		DupColorObjProc _ANSI_ARGS_((Tcl_Obj *srcObjPtr,
-			    Tcl_Obj *dupObjPtr));
-static void		FreeColorObjProc _ANSI_ARGS_((Tcl_Obj *objPtr));
-static void		InitColorObj _ANSI_ARGS_((Tcl_Obj *objPtr));
+static void		ColorInit(TkDisplay *dispPtr);
+static void		DupColorObjProc(Tcl_Obj *srcObjPtr,Tcl_Obj *dupObjPtr);
+static void		FreeColorObjProc(Tcl_Obj *objPtr);
+static void		InitColorObj(Tcl_Obj *objPtr);
 
 /*
  * The following structure defines the implementation of the "color" Tcl
- * object, which maps a string color name to a TkColor object.  The
- * ptr1 field of the Tcl_Obj points to a TkColor object.
+ * object, which maps a string color name to a TkColor object. The ptr1 field
+ * of the Tcl_Obj points to a TkColor object.
  */
 
 Tcl_ObjType tkColorObjType = {
@@ -67,32 +66,31 @@ Tcl_ObjType tkColorObjType = {
  *
  * Tk_AllocColorFromObj --
  *
- *	Given a Tcl_Obj *, map the value to a corresponding
- *	XColor structure based on the tkwin given.
+ *	Given a Tcl_Obj *, map the value to a corresponding XColor structure
+ *	based on the tkwin given.
  *
  * Results:
- *	The return value is a pointer to an XColor structure that
- *	indicates the red, blue, and green intensities for the color
- *	given by the string in objPtr, and also specifies a pixel value 
- *	to use to draw in that color.  If an error occurs, NULL is 
- *	returned and an error message will be left in interp's result
- *	(unless interp is NULL).
+ *	The return value is a pointer to an XColor structure that indicates
+ *	the red, blue, and green intensities for the color given by the string
+ *	in objPtr, and also specifies a pixel value to use to draw in that
+ *	color. If an error occurs, NULL is returned and an error message will
+ *	be left in interp's result (unless interp is NULL).
  *
  * Side effects:
- *	The color is added to an internal database with a reference count.
- *	For each call to this procedure, there should eventually be a call
- *	to Tk_FreeColorFromObj so that the database is cleaned up when colors
+ *	The color is added to an internal database with a reference count. For
+ *	each call to this function, there should eventually be a call to
+ *	Tk_FreeColorFromObj so that the database is cleaned up when colors
  *	aren't in use anymore.
  *
  *----------------------------------------------------------------------
  */
 
 XColor *
-Tk_AllocColorFromObj(interp, tkwin, objPtr)
-    Tcl_Interp *interp;		/* Used only for error reporting.  If NULL,
+Tk_AllocColorFromObj(
+    Tcl_Interp *interp,		/* Used only for error reporting. If NULL,
 				 * then no messages are provided. */
-    Tk_Window tkwin;		/* Window in which the color will be used.*/
-    Tcl_Obj *objPtr;		/* Object that describes the color; string
+    Tk_Window tkwin,		/* Window in which the color will be used.*/
+    Tcl_Obj *objPtr)		/* Object that describes the color; string
 				 * value is a color name such as "red" or
 				 * "#ff0000".*/
 {
@@ -104,15 +102,15 @@ Tk_AllocColorFromObj(interp, tkwin, objPtr)
     tkColPtr = (TkColor *) objPtr->internalRep.twoPtrValue.ptr1;
 
     /*
-     * If the object currently points to a TkColor, see if it's the
-     * one we want.  If so, increment its reference count and return.
+     * If the object currently points to a TkColor, see if it's the one we
+     * want. If so, increment its reference count and return.
      */
 
     if (tkColPtr != NULL) {
 	if (tkColPtr->resourceRefCount == 0) {
 	    /*
-	     * This is a stale reference: it refers to a TkColor that's
-	     * no longer in use.  Clear the reference.
+	     * This is a stale reference: it refers to a TkColor that's no
+	     * longer in use. Clear the reference.
 	     */
 
 	    FreeColorObjProc(objPtr);
@@ -125,14 +123,14 @@ Tk_AllocColorFromObj(interp, tkwin, objPtr)
     }
 
     /*
-     * The object didn't point to the TkColor that we wanted.  Search
-     * the list of TkColors with the same name to see if one of the
-     * other TkColors is the right one.
+     * The object didn't point to the TkColor that we wanted. Search the list
+     * of TkColors with the same name to see if one of the other TkColors is
+     * the right one.
      */
 
     if (tkColPtr != NULL) {
-	TkColor *firstColorPtr = 
-		(TkColor *) Tcl_GetHashValue(tkColPtr->hashPtr);
+	TkColor *firstColorPtr = (TkColor *)
+		Tcl_GetHashValue(tkColPtr->hashPtr);
 	FreeColorObjProc(objPtr);
 	for (tkColPtr = firstColorPtr; tkColPtr != NULL;
 		tkColPtr = tkColPtr->nextPtr) {
@@ -140,18 +138,18 @@ Tk_AllocColorFromObj(interp, tkwin, objPtr)
 		    && (Tk_Colormap(tkwin) == tkColPtr->colormap)) {
 		tkColPtr->resourceRefCount++;
 		tkColPtr->objRefCount++;
-		objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) tkColPtr;
+		objPtr->internalRep.twoPtrValue.ptr1 = (void *) tkColPtr;
 		return (XColor *) tkColPtr;
 	    }
 	}
     }
 
     /*
-     * Still no luck.  Call Tk_GetColor to allocate a new TkColor object.
+     * Still no luck. Call Tk_GetColor to allocate a new TkColor object.
      */
 
     tkColPtr = (TkColor *) Tk_GetColor(interp, tkwin, Tcl_GetString(objPtr));
-    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) tkColPtr;
+    objPtr->internalRep.twoPtrValue.ptr1 = (void *) tkColPtr;
     if (tkColPtr != NULL) {
 	tkColPtr->objRefCount++;
     }
@@ -167,27 +165,27 @@ Tk_AllocColorFromObj(interp, tkwin, objPtr)
  *	XColor structure.
  *
  * Results:
- *	The return value is a pointer to an XColor structure that
- *	indicates the red, blue, and green intensities for the color
- *	given by "name", and also specifies a pixel value to use to
- *	draw in that color.  If an error occurs, NULL is returned and
- *	an error message will be left in the interp's result.
+ *	The return value is a pointer to an XColor structure that indicates
+ *	the red, blue, and green intensities for the color given by "name",
+ *	and also specifies a pixel value to use to draw in that color. If an
+ *	error occurs, NULL is returned and an error message will be left in
+ *	the interp's result.
  *
  * Side effects:
- *	The color is added to an internal database with a reference count.
- *	For each call to this procedure, there should eventually be a call
- *	to Tk_FreeColor so that the database is cleaned up when colors
- *	aren't in use anymore.
+ *	The color is added to an internal database with a reference count. For
+ *	each call to this function, there should eventually be a call to
+ *	Tk_FreeColor so that the database is cleaned up when colors aren't in
+ *	use anymore.
  *
  *----------------------------------------------------------------------
  */
 
 XColor *
-Tk_GetColor(interp, tkwin, name)
-    Tcl_Interp *interp;		/* Place to leave error message if
-				 * color can't be found. */
-    Tk_Window tkwin;		/* Window in which color will be used. */
-    Tk_Uid name;		/* Name of color to be allocated (in form
+Tk_GetColor(
+    Tcl_Interp *interp,		/* Place to leave error message if color can't
+				 * be found. */
+    Tk_Window tkwin,		/* Window in which color will be used. */
+    Tk_Uid name)		/* Name of color to be allocated (in form
 				 * suitable for passing to XParseColor). */
 {
     Tcl_HashEntry *nameHashPtr;
@@ -201,14 +199,13 @@ Tk_GetColor(interp, tkwin, name)
     }
 
     /*
-     * First, check to see if there's already a mapping for this color
-     * name.
+     * First, check to see if there's already a mapping for this color name.
      */
 
     nameHashPtr = Tcl_CreateHashEntry(&dispPtr->colorNameTable, name, &new);
     if (!new) {
 	existingColPtr = (TkColor *) Tcl_GetHashValue(nameHashPtr);
-	for (tkColPtr = existingColPtr;  tkColPtr != NULL;
+	for (tkColPtr = existingColPtr; tkColPtr != NULL;
 		tkColPtr = tkColPtr->nextPtr) {
 	    if ((tkColPtr->screen == Tk_Screen(tkwin))
 		    && (Tk_Colormap(tkwin) == tkColPtr->colormap)) {
@@ -221,8 +218,7 @@ Tk_GetColor(interp, tkwin, name)
     }
 
     /*
-     * The name isn't currently known.  Map from the name to a pixel
-     * value.
+     * The name isn't currently known. Map from the name to a pixel value.
      */
 
     tkColPtr = TkpGetColor(tkwin, name);
@@ -230,28 +226,28 @@ Tk_GetColor(interp, tkwin, name)
 	if (interp != NULL) {
 	    if (*name == '#') {
 		Tcl_AppendResult(interp, "invalid color name \"", name,
-			"\"", (char *) NULL);
+			"\"", NULL);
 	    } else {
 		Tcl_AppendResult(interp, "unknown color name \"", name,
-			"\"", (char *) NULL);
+			"\"", NULL);
 	    }
 	}
 	if (new) {
 	    Tcl_DeleteHashEntry(nameHashPtr);
 	}
-	return (XColor *) NULL;
+	return NULL;
     }
 
     /*
-     * Now create a new TkColor structure and add it to colorNameTable
-     * (in TkDisplay).
+     * Now create a new TkColor structure and add it to colorNameTable (in
+     * TkDisplay).
      */
 
     tkColPtr->magic = COLOR_MAGIC;
     tkColPtr->gc = None;
     tkColPtr->screen = Tk_Screen(tkwin);
     tkColPtr->colormap = Tk_Colormap(tkwin);
-    tkColPtr->visual  = Tk_Visual(tkwin);
+    tkColPtr->visual = Tk_Visual(tkwin);
     tkColPtr->resourceRefCount = 1;
     tkColPtr->objRefCount = 0;
     tkColPtr->type = TK_COLOR_BY_NAME;
@@ -267,29 +263,28 @@ Tk_GetColor(interp, tkwin, name)
  *
  * Tk_GetColorByValue --
  *
- *	Given a desired set of red-green-blue intensities for a color,
- *	locate a pixel value to use to draw that color in a given
- *	window.
+ *	Given a desired set of red-green-blue intensities for a color, locate
+ *	a pixel value to use to draw that color in a given window.
  *
  * Results:
- *	The return value is a pointer to an XColor structure that
- *	indicates the closest red, blue, and green intensities available
- *	to those specified in colorPtr, and also specifies a pixel
- *	value to use to draw in that color.
+ *	The return value is a pointer to an XColor structure that indicates
+ *	the closest red, blue, and green intensities available to those
+ *	specified in colorPtr, and also specifies a pixel value to use to draw
+ *	in that color.
  *
  * Side effects:
- *	The color is added to an internal database with a reference count.
- *	For each call to this procedure, there should eventually be a call
- *	to Tk_FreeColor, so that the database is cleaned up when colors
- *	aren't in use anymore.
+ *	The color is added to an internal database with a reference count. For
+ *	each call to this function, there should eventually be a call to
+ *	Tk_FreeColor, so that the database is cleaned up when colors aren't in
+ *	use anymore.
  *
  *----------------------------------------------------------------------
  */
 
 XColor *
-Tk_GetColorByValue(tkwin, colorPtr)
-    Tk_Window tkwin;		/* Window where color will be used. */
-    XColor *colorPtr;		/* Red, green, and blue fields indicate
+Tk_GetColorByValue(
+    Tk_Window tkwin,		/* Window where color will be used. */
+    XColor *colorPtr)		/* Red, green, and blue fields indicate
 				 * desired color. */
 {
     ValueKey valueKey;
@@ -304,8 +299,7 @@ Tk_GetColorByValue(tkwin, colorPtr)
     }
 
     /*
-     * First, check to see if there's already a mapping for this color
-     * name.
+     * First, check to see if there's already a mapping for this color name.
      */
 
     valueKey.red = colorPtr->red;
@@ -313,8 +307,8 @@ Tk_GetColorByValue(tkwin, colorPtr)
     valueKey.blue = colorPtr->blue;
     valueKey.colormap = Tk_Colormap(tkwin);
     valueKey.display = display;
-    valueHashPtr = Tcl_CreateHashEntry(&dispPtr->colorValueTable, 
-            (char *) &valueKey, &new);
+    valueHashPtr = Tcl_CreateHashEntry(&dispPtr->colorValueTable,
+	    (char *) &valueKey, &new);
     if (!new) {
 	tkColPtr = (TkColor *) Tcl_GetHashValue(valueHashPtr);
 	tkColPtr->resourceRefCount++;
@@ -322,8 +316,8 @@ Tk_GetColorByValue(tkwin, colorPtr)
     }
 
     /*
-     * The name isn't currently known.  Find a pixel value for this
-     * color and add a new structure to colorValueTable (in TkDisplay).
+     * The name isn't currently known. Find a pixel value for this color and
+     * add a new structure to colorValueTable (in TkDisplay).
      */
 
     tkColPtr = TkpGetColorByValue(tkwin, colorPtr);
@@ -331,7 +325,7 @@ Tk_GetColorByValue(tkwin, colorPtr)
     tkColPtr->gc = None;
     tkColPtr->screen = Tk_Screen(tkwin);
     tkColPtr->colormap = valueKey.colormap;
-    tkColPtr->visual  = Tk_Visual(tkwin);
+    tkColPtr->visual = Tk_Visual(tkwin);
     tkColPtr->resourceRefCount = 1;
     tkColPtr->objRefCount = 0;
     tkColPtr->type = TK_COLOR_BY_VALUE;
@@ -346,16 +340,14 @@ Tk_GetColorByValue(tkwin, colorPtr)
  *
  * Tk_NameOfColor --
  *
- *	Given a color, return a textual string identifying
- *	the color.
+ *	Given a color, return a textual string identifying the color.
  *
  * Results:
- *	If colorPtr was created by Tk_GetColor, then the return
- *	value is the "string" that was used to create it.
- *	Otherwise the return value is a string that could have
- *	been passed to Tk_GetColor to allocate that color.  The
- *	storage for the returned string is only guaranteed to
- *	persist up until the next call to this procedure.
+ *	If colorPtr was created by Tk_GetColor, then the return value is the
+ *	"string" that was used to create it. Otherwise the return value is a
+ *	string that could have been passed to Tk_GetColor to allocate that
+ *	color. The storage for the returned string is only guaranteed to
+ *	persist up until the next call to this function.
  *
  * Side effects:
  *	None.
@@ -364,18 +356,18 @@ Tk_GetColorByValue(tkwin, colorPtr)
  */
 
 CONST char *
-Tk_NameOfColor(colorPtr)
-    XColor *colorPtr;		/* Color whose name is desired. */
+Tk_NameOfColor(
+    XColor *colorPtr)		/* Color whose name is desired. */
 {
     register TkColor *tkColPtr = (TkColor *) colorPtr;
-    
-    if ((tkColPtr->magic == COLOR_MAGIC) &&
-	    (tkColPtr->type == TK_COLOR_BY_NAME)) {
+
+    if (tkColPtr->magic==COLOR_MAGIC && tkColPtr->type==TK_COLOR_BY_NAME) {
 	return tkColPtr->hashPtr->key.string;
     } else {
-	ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
-            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
-	sprintf(tsdPtr->rgbString, "#%04x%04x%04x", colorPtr->red, 
+	ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+		Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+
+	sprintf(tsdPtr->rgbString, "#%04x%04x%04x", colorPtr->red,
 		colorPtr->green, colorPtr->blue);
 	return tsdPtr->rgbString;
     }
@@ -386,15 +378,14 @@ Tk_NameOfColor(colorPtr)
  *
  * Tk_GCForColor --
  *
- *	Given a color allocated from this module, this procedure
- *	returns a GC that can be used for simple drawing with that
- *	color.
+ *	Given a color allocated from this module, this function returns a GC
+ *	that can be used for simple drawing with that color.
  *
  * Results:
- *	The return value is a GC with color set as its foreground
- *	color and all other fields defaulted.  This GC is only valid
- *	as long as the color exists;  it is freed automatically when
- *	the last reference to the color is freed.
+ *	The return value is a GC with color set as its foreground color and
+ *	all other fields defaulted. This GC is only valid as long as the color
+ *	exists; it is freed automatically when the last reference to the color
+ *	is freed.
  *
  * Side effects:
  *	None.
@@ -403,20 +394,19 @@ Tk_NameOfColor(colorPtr)
  */
 
 GC
-Tk_GCForColor(colorPtr, drawable)
-    XColor *colorPtr;		/* Color for which a GC is desired. Must
-				 * have been allocated by Tk_GetColor. */
-    Drawable drawable;		/* Drawable in which the color will be
-				 * used (must have same screen and depth
-				 * as the one for which the color was
-				 * allocated). */
+Tk_GCForColor(
+    XColor *colorPtr,		/* Color for which a GC is desired. Must have
+				 * been allocated by Tk_GetColor. */
+    Drawable drawable)		/* Drawable in which the color will be used
+				 * (must have same screen and depth as the one
+				 * for which the color was allocated). */
 {
     TkColor *tkColPtr = (TkColor *) colorPtr;
     XGCValues gcValues;
 
     /*
-     * Do a quick sanity check to make sure this color was really
-     * allocated by Tk_GetColor.
+     * Do a quick sanity check to make sure this color was really allocated by
+     * Tk_GetColor.
      */
 
     if (tkColPtr->magic != COLOR_MAGIC) {
@@ -436,23 +426,21 @@ Tk_GCForColor(colorPtr, drawable)
  *
  * Tk_FreeColor --
  *
- *	This procedure is called to release a color allocated by
- *	Tk_GetColor.
+ *	This function is called to release a color allocated by Tk_GetColor.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The reference count associated with colorPtr is deleted, and
- *	the color is released to X if there are no remaining uses
- *	for it.
+ *	The reference count associated with colorPtr is deleted, and the color
+ *	is released to X if there are no remaining uses for it.
  *
  *----------------------------------------------------------------------
  */
 
 void
-Tk_FreeColor(colorPtr)
-    XColor *colorPtr;		/* Color to be released.  Must have been
+Tk_FreeColor(
+    XColor *colorPtr)		/* Color to be released. Must have been
 				 * allocated by Tk_GetColor or
 				 * Tk_GetColorByValue. */
 {
@@ -461,8 +449,8 @@ Tk_FreeColor(colorPtr)
     TkColor *prevPtr;
 
     /*
-     * Do a quick sanity check to make sure this color was really
-     * allocated by Tk_GetColor.
+     * Do a quick sanity check to make sure this color was really allocated by
+     * Tk_GetColor.
      */
 
     if (tkColPtr->magic != COLOR_MAGIC) {
@@ -476,8 +464,8 @@ Tk_FreeColor(colorPtr)
 
     /*
      * This color is no longer being actively used, so free the color
-     * resources associated with it and remove it from the hash table.
-     * no longer any objects referencing it.
+     * resources associated with it and remove it from the hash table. No
+     * longer any objects referencing it.
      */
 
     if (tkColPtr->gc != None) {
@@ -490,7 +478,7 @@ Tk_FreeColor(colorPtr)
     if (prevPtr == tkColPtr) {
 	if (tkColPtr->nextPtr == NULL) {
 	    Tcl_DeleteHashEntry(tkColPtr->hashPtr);
-	} else  {
+	} else {
 	    Tcl_SetHashValue(tkColPtr->hashPtr, tkColPtr->nextPtr);
 	}
     } else {
@@ -501,10 +489,9 @@ Tk_FreeColor(colorPtr)
     }
 
     /*
-     * Free the TkColor structure if there are no objects referencing
-     * it.  However, if there are objects referencing it then keep the
-     * structure around; it will get freed when the last reference is
-     * cleared
+     * Free the TkColor structure if there are no objects referencing it.
+     * However, if there are objects referencing it then keep the structure
+     * around; it will get freed when the last reference is cleared
      */
 
     if (tkColPtr->objRefCount == 0) {
@@ -517,27 +504,27 @@ Tk_FreeColor(colorPtr)
  *
  * Tk_FreeColorFromObj --
  *
- *	This procedure is called to release a color allocated by
- *	Tk_AllocColorFromObj. It does not throw away the Tcl_Obj *;
- *	it only gets rid of the hash table entry for this color
- *	and clears the cached value that is normally stored in the object.
+ *	This function is called to release a color allocated by
+ *	Tk_AllocColorFromObj. It does not throw away the Tcl_Obj *; it only
+ *	gets rid of the hash table entry for this color and clears the cached
+ *	value that is normally stored in the object.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The reference count associated with the color represented by
- *	objPtr is decremented, and the color is released to X if there are 
- *	no remaining uses for it.
+ *	The reference count associated with the color represented by objPtr is
+ *	decremented, and the color is released to X if there are no remaining
+ *	uses for it.
  *
  *----------------------------------------------------------------------
  */
 
 void
-Tk_FreeColorFromObj(tkwin, objPtr)
-    Tk_Window tkwin;		/* The window this color lives in. Needed
-				 * for the screen and colormap values. */
-    Tcl_Obj *objPtr;		/* The Tcl_Obj * to be freed. */
+Tk_FreeColorFromObj(
+    Tk_Window tkwin,		/* The window this color lives in. Needed for
+				 * the screen and colormap values. */
+    Tcl_Obj *objPtr)		/* The Tcl_Obj * to be freed. */
 {
     Tk_FreeColor(Tk_GetColorFromObj(tkwin, objPtr));
     FreeColorObjProc(objPtr);
@@ -546,66 +533,65 @@ Tk_FreeColorFromObj(tkwin, objPtr)
 /*
  *---------------------------------------------------------------------------
  *
- * FreeColorObjProc -- 
+ * FreeColorObjProc --
  *
- *	This proc is called to release an object reference to a color.
- *	Called when the object's internal rep is released or when
- *	the cached tkColPtr needs to be changed.
+ *	This proc is called to release an object reference to a color. Called
+ *	when the object's internal rep is released or when the cached tkColPtr
+ *	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 color's resources
- *	are released.
+ *	The object reference count is decremented. When both it and the hash
+ *	ref count go to zero, the color's resources are released.
  *
  *---------------------------------------------------------------------------
  */
 
 static void
-FreeColorObjProc(objPtr)
-    Tcl_Obj *objPtr;		/* The object we are releasing. */
+FreeColorObjProc(
+    Tcl_Obj *objPtr)		/* The object we are releasing. */
 {
     TkColor *tkColPtr = (TkColor *) objPtr->internalRep.twoPtrValue.ptr1;
 
     if (tkColPtr != NULL) {
 	tkColPtr->objRefCount--;
-	if ((tkColPtr->objRefCount == 0) 
+	if ((tkColPtr->objRefCount == 0)
 		&& (tkColPtr->resourceRefCount == 0)) {
 	    ckfree((char *) tkColPtr);
 	}
-	objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) NULL;
+	objPtr->internalRep.twoPtrValue.ptr1 = NULL;
     }
 }
 
 /*
  *---------------------------------------------------------------------------
  *
- * DupColorObjProc -- 
+ * DupColorObjProc --
  *
- *	When a cached color object is duplicated, this is called to
- *	update the internal reps.
+ *	When a cached color object is duplicated, this is called to update the
+ *	internal reps.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The color's objRefCount is incremented and the internal rep
- *	of the copy is set to point to it.
+ *	The color's objRefCount is incremented and the internal rep of the
+ *	copy is set to point to it.
  *
  *---------------------------------------------------------------------------
  */
 
 static void
-DupColorObjProc(srcObjPtr, dupObjPtr)
-    Tcl_Obj *srcObjPtr;		/* The object we are copying from. */
-    Tcl_Obj *dupObjPtr;		/* The object we are copying to. */
+DupColorObjProc(
+    Tcl_Obj *srcObjPtr,		/* The object we are copying from. */
+    Tcl_Obj *dupObjPtr)		/* The object we are copying to. */
 {
     TkColor *tkColPtr = (TkColor *) srcObjPtr->internalRep.twoPtrValue.ptr1;
-    
+
     dupObjPtr->typePtr = srcObjPtr->typePtr;
-    dupObjPtr->internalRep.twoPtrValue.ptr1 = (VOID *) tkColPtr;
+    dupObjPtr->internalRep.twoPtrValue.ptr1 = (void *) tkColPtr;
 
     if (tkColPtr != NULL) {
 	tkColPtr->objRefCount++;
@@ -617,26 +603,25 @@ DupColorObjProc(srcObjPtr, dupObjPtr)
  *
  * Tk_GetColorFromObj --
  *
- *	Returns the color referred to by a Tcl object.  The color must
- *	already have been allocated via a call to Tk_AllocColorFromObj
- *	or Tk_GetColor.
+ *	Returns the color referred to by a Tcl object. The color must already
+ *	have been allocated via a call to Tk_AllocColorFromObj or Tk_GetColor.
  *
  * Results:
- *	Returns the XColor * that matches the tkwin and the string rep
- *	of objPtr.
+ *	Returns the XColor * that matches the tkwin and the string rep of
+ *	objPtr.
  *
  * Side effects:
- *	If the object is not already a color, the conversion will free
- *	any old internal representation. 
+ *	If the object is not already a color, the conversion will free any old
+ *	internal representation.
  *
  *----------------------------------------------------------------------
  */
 
 XColor *
-Tk_GetColorFromObj(tkwin, objPtr)
-    Tk_Window tkwin;		/* The window in which the color will be
+Tk_GetColorFromObj(
+    Tk_Window tkwin,		/* The window in which the color will be
 				 * used. */
-    Tcl_Obj *objPtr;		/* String value contains the name of the
+    Tcl_Obj *objPtr)		/* String value contains the name of the
 				 * desired color. */
 {
     TkColor *tkColPtr;
@@ -646,34 +631,35 @@ Tk_GetColorFromObj(tkwin, objPtr)
     if (objPtr->typePtr != &tkColorObjType) {
 	InitColorObj(objPtr);
     }
-  
+
     /*
-     * First check to see if the internal representation of the object
-     * is defined and is a color that is valid for the current screen
-     * and color map.  If it is, we are done.
+     * First check to see if the internal representation of the object is
+     * defined and is a color that is valid for the current screen and color
+     * map. If it is, we are done.
      */
+
     tkColPtr = (TkColor *) objPtr->internalRep.twoPtrValue.ptr1;
     if ((tkColPtr != NULL)
 	    && (tkColPtr->resourceRefCount > 0)
 	    && (Tk_Screen(tkwin) == tkColPtr->screen)
 	    && (Tk_Colormap(tkwin) == tkColPtr->colormap)) {
 	/*
-	 * The object already points to the right TkColor structure.
-	 * Just return it.
+	 * The object already points to the right TkColor structure. Just
+	 * return it.
 	 */
 
 	return (XColor *) tkColPtr;
     }
 
     /*
-     * If we reach this point, it means that the TkColor structure
-     * that we have cached in the internal representation is not valid
-     * for the current screen and colormap.  But there is a list of
-     * other TkColor structures attached to the TkDisplay.  Walk this
-     * list looking for the right TkColor structure.
+     * If we reach this point, it means that the TkColor structure that we
+     * have cached in the internal representation is not valid for the current
+     * screen and colormap. But there is a list of other TkColor structures
+     * attached to the TkDisplay. Walk this list looking for the right TkColor
+     * structure.
      */
 
-    hashPtr = Tcl_FindHashEntry(&dispPtr->colorNameTable, 
+    hashPtr = Tcl_FindHashEntry(&dispPtr->colorNameTable,
 	    Tcl_GetString(objPtr));
     if (hashPtr == NULL) {
 	goto error;
@@ -683,14 +669,14 @@ Tk_GetColorFromObj(tkwin, objPtr)
 	if ((Tk_Screen(tkwin) == tkColPtr->screen)
 		&& (Tk_Colormap(tkwin) == tkColPtr->colormap)) {
 	    FreeColorObjProc(objPtr);
-	    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) tkColPtr;
+	    objPtr->internalRep.twoPtrValue.ptr1 = (void *) tkColPtr;
 	    tkColPtr->objRefCount++;
 	    return (XColor *) tkColPtr;
 	}
     }
 
-    error:
-    Tcl_Panic(" Tk_GetColorFromObj called with non-existent color!");
+  error:
+    Tcl_Panic("Tk_GetColorFromObj called with non-existent color!");
     /*
      * The following code isn't reached; it's just there to please compilers.
      */
@@ -702,28 +688,27 @@ Tk_GetColorFromObj(tkwin, objPtr)
  *
  * InitColorObj --
  *
- *	Bookeeping procedure to change an objPtr to a color type.
+ *	Bookeeping function to change an objPtr to a color type.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The old internal rep of the object is freed. The object's
- *	type is set to color with a NULL TkColor pointer (the pointer
- *	will be set later by either Tk_AllocColorFromObj or
- *	Tk_GetColorFromObj).
+ *	The old internal rep of the object is freed. The object's type is set
+ *	to color with a NULL TkColor pointer (the pointer will be set later by
+ *	either Tk_AllocColorFromObj or Tk_GetColorFromObj).
  *
  *----------------------------------------------------------------------
  */
 
 static void
-InitColorObj(objPtr)
-    Tcl_Obj *objPtr;		/* The object to convert. */
+InitColorObj(
+    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);
@@ -732,7 +717,7 @@ InitColorObj(objPtr)
 	(*typePtr->freeIntRepProc)(objPtr);
     }
     objPtr->typePtr = &tkColorObjType;
-    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) NULL;
+    objPtr->internalRep.twoPtrValue.ptr1 = NULL;
 }
 
 /*
@@ -756,10 +741,10 @@ ColorInit(dispPtr)
     TkDisplay *dispPtr;
 {
     if (!dispPtr->colorInit) {
-        dispPtr->colorInit = 1;
+	dispPtr->colorInit = 1;
 	Tcl_InitHashTable(&dispPtr->colorNameTable, TCL_STRING_KEYS);
-	Tcl_InitHashTable(&dispPtr->colorValueTable, 
-                sizeof(ValueKey)/sizeof(int));
+	Tcl_InitHashTable(&dispPtr->colorValueTable,
+		sizeof(ValueKey)/sizeof(int));
     }
 }
 
@@ -768,13 +753,13 @@ ColorInit(dispPtr)
  *
  * TkDebugColor --
  *
- *	This procedure returns debugging information about a color.
+ *	This function returns debugging information about a color.
  *
  * Results:
  *	The return value is a list with one sublist for each TkColor
- *	corresponding to "name".  Each sublist has two elements that
- *	contain the resourceRefCount and objRefCount fields from the
- *	TkColor structure.
+ *	corresponding to "name". Each sublist has two elements that contain
+ *	the resourceRefCount and objRefCount fields from the TkColor
+ *	structure.
  *
  * Side effects:
  *	None.
@@ -783,31 +768,40 @@ ColorInit(dispPtr)
  */
 
 Tcl_Obj *
-TkDebugColor(tkwin, name)
-    Tk_Window tkwin;		/* The window in which the color will be
-				 * used (not currently used). */
-    char *name;			/* Name of the desired color. */
+TkDebugColor(
+    Tk_Window tkwin,		/* The window in which the color will be used
+				 * (not currently used). */
+    char *name)			/* Name of the desired color. */
 {
-    TkColor *tkColPtr;
     Tcl_HashEntry *hashPtr;
-    Tcl_Obj *resultPtr, *objPtr;
+    Tcl_Obj *resultPtr;
     TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
 
     resultPtr = Tcl_NewObj();
     hashPtr = Tcl_FindHashEntry(&dispPtr->colorNameTable, name);
     if (hashPtr != NULL) {
-	tkColPtr = (TkColor *) Tcl_GetHashValue(hashPtr);
+	TkColor *tkColPtr = (TkColor *) Tcl_GetHashValue(hashPtr);
+
 	if (tkColPtr == NULL) {
 	    Tcl_Panic("TkDebugColor found empty hash table entry");
 	}
 	for ( ; (tkColPtr != NULL); tkColPtr = tkColPtr->nextPtr) {
-	    objPtr = Tcl_NewObj();
+	    Tcl_Obj *objPtr = Tcl_NewObj();
+
 	    Tcl_ListObjAppendElement(NULL, objPtr,
 		    Tcl_NewIntObj(tkColPtr->resourceRefCount));
 	    Tcl_ListObjAppendElement(NULL, objPtr,
-		    Tcl_NewIntObj(tkColPtr->objRefCount)); 
+		    Tcl_NewIntObj(tkColPtr->objRefCount));
 	    Tcl_ListObjAppendElement(NULL, resultPtr, objPtr);
 	}
     }
     return resultPtr;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/generic/tkEvent.c b/generic/tkEvent.c
index ceffd0a..b9527f3 100644
--- a/generic/tkEvent.c
+++ b/generic/tkEvent.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * tkEvent.c --
  *
  *	This file provides basic low-level facilities for managing X events in
@@ -12,7 +12,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkEvent.c,v 1.30 2005/09/28 18:31:57 dgp Exp $
+ * RCS: @(#) $Id: tkEvent.c,v 1.31 2005/11/04 11:52:50 dkf Exp $
  */
 
 #include "tkPort.h"
@@ -1290,7 +1290,7 @@ Tk_HandleEvent(
     TkWindow *winPtr;
     unsigned long mask;
     InProgress ip;
-    Tcl_Interp *interp = (Tcl_Interp *) NULL;
+    Tcl_Interp *interp = NULL;
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
 	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
@@ -1431,7 +1431,7 @@ Tk_HandleEvent(
      */
 
   releaseInterpreter:
-    if (interp != (Tcl_Interp *) NULL) {
+    if (interp != NULL) {
 	Tcl_Release((ClientData) interp);
     }
 
diff --git a/generic/tkFileFilter.c b/generic/tkFileFilter.c
index 59b9985..0ae1e64 100644
--- a/generic/tkFileFilter.c
+++ b/generic/tkFileFilter.c
@@ -6,34 +6,31 @@
  *
  * Copyright (c) 1996 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: tkFileFilter.c,v 1.8 2005/05/23 23:19:35 hobbs Exp $
+ * RCS: @(#) $Id: tkFileFilter.c,v 1.9 2005/11/04 11:52:50 dkf Exp $
  */
 
 #include "tkInt.h"
 #include "tkFileFilter.h"
 
-static int		AddClause _ANSI_ARGS_((Tcl_Interp *interp,
+static int		AddClause(Tcl_Interp *interp,
 			    FileFilter *filterPtr, Tcl_Obj *patternsObj,
-			    Tcl_Obj *ostypesObj, int isWindows));
-static void		FreeClauses _ANSI_ARGS_((FileFilter *filterPtr));
-static void		FreeGlobPatterns _ANSI_ARGS_((
-			    FileFilterClause *clausePtr));
-static void		FreeMacFileTypes _ANSI_ARGS_((
-			    FileFilterClause *clausePtr));
-static FileFilter *	GetFilter _ANSI_ARGS_((FileFilterList *flistPtr,
-			    CONST char *name));
+			    Tcl_Obj *ostypesObj, int isWindows);
+static void		FreeClauses(FileFilter *filterPtr);
+static void		FreeGlobPatterns(FileFilterClause *clausePtr);
+static void		FreeMacFileTypes(FileFilterClause *clausePtr);
+static FileFilter *	GetFilter(FileFilterList *flistPtr, CONST char *name);
 
 /*
  *----------------------------------------------------------------------
  *
  * TkInitFileFilters --
  *
- *	Initializes a FileFilterList data structure. A FileFilterList
- *	must be initialized EXACTLY ONCE before any calls to
- *	TkGetFileFilters() is made. The usual flow of control is:
+ *	Initializes a FileFilterList data structure. A FileFilterList must be
+ *	initialized EXACTLY ONCE before any calls to TkGetFileFilters() is
+ *	made. The usual flow of control is:
  *		TkInitFileFilters(&flist);
  *		    TkGetFileFilters(&flist, ...);
  *		    TkGetFileFilters(&flist, ...);
@@ -45,12 +42,13 @@ static FileFilter *	GetFilter _ANSI_ARGS_((FileFilterList *flistPtr,
  *
  * Side effects:
  *	The fields in flistPtr are initialized.
+ *
  *----------------------------------------------------------------------
  */
 
 void
-TkInitFileFilters(flistPtr)
-    FileFilterList *flistPtr;	/* The structure to be initialized. */
+TkInitFileFilters(
+    FileFilterList *flistPtr)	/* The structure to be initialized. */
 {
     flistPtr->filters = NULL;
     flistPtr->filtersTail = NULL;
@@ -62,11 +60,11 @@ TkInitFileFilters(flistPtr)
  *
  * TkGetFileFilters --
  *
- *	This function is called by the Mac and Windows implementation
- *	of tk_getOpenFile and tk_getSaveFile to translate the string
- *	value of the -filetypes option into an easy-to-parse C
- *	structure (flistPtr). The caller of this function will then use
- *	flistPtr to perform filetype matching in a platform specific way.
+ *	This function is called by the Mac and Windows implementation of
+ *	tk_getOpenFile and tk_getSaveFile to translate the string value of the
+ *	-filetypes option into an easy-to-parse C structure (flistPtr). The
+ *	caller of this function will then use flistPtr to perform filetype
+ *	matching in a platform specific way.
  *
  *	flistPtr must be initialized (See comments in TkInitFileFilters).
  *
@@ -75,14 +73,16 @@ TkInitFileFilters(flistPtr)
  *
  * Side effects:
  *	The fields in flistPtr are changed according to 'types'.
+ *
  *----------------------------------------------------------------------
  */
+
 int
-TkGetFileFilters(interp, flistPtr, types, isWindows)
-    Tcl_Interp *interp;		/* Interpreter to use for error reporting. */
-    FileFilterList *flistPtr;	/* Stores the list of file filters. */
-    Tcl_Obj *types;		/* Value of the -filetypes option. */
-    int isWindows;		/* True if we are running on Windows. */
+TkGetFileFilters(
+    Tcl_Interp *interp,		/* Interpreter to use for error reporting. */
+    FileFilterList *flistPtr,	/* Stores the list of file filters. */
+    Tcl_Obj *types,		/* Value of the -filetypes option. */
+    int isWindows)		/* True if we are running on Windows. */
 {
     int listObjc;
     Tcl_Obj ** listObjv = NULL;
@@ -91,7 +91,7 @@ TkGetFileFilters(interp, flistPtr, types, isWindows)
     if (types == NULL) {
         return TCL_OK;
     }
-    
+
     if (Tcl_ListObjGetElements(interp, types, &listObjc,
 	    &listObjv) != TCL_OK) {
 	return TCL_ERROR;
@@ -101,38 +101,39 @@ TkGetFileFilters(interp, flistPtr, types, isWindows)
     }
 
     /*
-     * Free the filter information that have been allocated the previous
-     * time -- the -filefilters option may have been used more than once in
-     * the command line.
+     * Free the filter information that have been allocated the previous time;
+     * the -filefilters option may have been used more than once in the
+     * command line.
      */
     TkFreeFileFilters(flistPtr);
 
     for (i = 0; i<listObjc; i++) {
 	/*
-	 * Each file type should have two or three elements: the first one
-	 * is the name of the type and the second is the filter of the type.
-	 * The third is the Mac OSType ID, but we don't care about them here.
+	 * Each file type should have two or three elements: the first one is
+	 * the name of the type and the second is the filter of the type. The
+	 * third is the Mac OSType ID, but we don't care about them here.
 	 */
+
 	int count;
 	FileFilter *filterPtr;
 	Tcl_Obj **typeInfo;
 
-	if (Tcl_ListObjGetElements(interp, listObjv[i], &count, 
+	if (Tcl_ListObjGetElements(interp, listObjv[i], &count,
 		&typeInfo) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	
+
 	if (count != 2 && count != 3) {
-	    Tcl_AppendResult(interp, "bad file type \"", 
-		Tcl_GetString(listObjv[i]), "\", ",
-		"should be \"typeName {extension ?extensions ...?} ",
-		"?{macType ?macTypes ...?}?\"",	NULL);
+	    Tcl_AppendResult(interp, "bad file type \"",
+		    Tcl_GetString(listObjv[i]), "\", ",
+		    "should be \"typeName {extension ?extensions ...?} ",
+		    "?{macType ?macTypes ...?}?\"", NULL);
 	    return TCL_ERROR;
 	}
 
 	filterPtr = GetFilter(flistPtr, Tcl_GetString(typeInfo[0]));
 
-	if (AddClause(interp, filterPtr, typeInfo[1], 
+	if (AddClause(interp, filterPtr, typeInfo[1],
 		(count==2 ? NULL : typeInfo[2]), isWindows) != TCL_OK) {
 	    return TCL_ERROR;
 	}
@@ -153,12 +154,13 @@ TkGetFileFilters(interp, flistPtr, types, isWindows)
  *
  * Side effects:
  *	The fields allocated by TkGetFileFilters() are freed.
+ *
  *----------------------------------------------------------------------
  */
 
 void
-TkFreeFileFilters(flistPtr)
-    FileFilterList *flistPtr;	/* List of file filters to free */
+TkFreeFileFilters(
+    FileFilterList *flistPtr)	/* List of file filters to free */
 {
     FileFilter *filterPtr, *toFree;
 
@@ -185,19 +187,20 @@ TkFreeFileFilters(flistPtr)
  *
  * Side effects:
  *	The list of filter clauses are updated in filterPtr.
+ *
  *----------------------------------------------------------------------
  */
 
 static int
-AddClause(interp, filterPtr, patternsObj, ostypesObj, isWindows)
-    Tcl_Interp *interp;		/* Interpreter to use for error reporting. */
-    FileFilter *filterPtr;	/* Stores the new filter clause */
-    Tcl_Obj *patternsObj;	/* A Tcl list of glob patterns. */
-    Tcl_Obj *ostypesObj;	/* A Tcl list of Mac OSType strings. */
-    int isWindows;		/* True if we are running on Windows; False
-				 * if we are running on the Mac; Glob
-				 * patterns need to be processed differently
-				 * on these two platforms */
+AddClause(
+    Tcl_Interp *interp,		/* Interpreter to use for error reporting. */
+    FileFilter *filterPtr,	/* Stores the new filter clause */
+    Tcl_Obj *patternsObj,	/* A Tcl list of glob patterns. */
+    Tcl_Obj *ostypesObj,	/* A Tcl list of Mac OSType strings. */
+    int isWindows)		/* True if we are running on Windows; False if
+				 * we are running on the Mac; Glob patterns
+				 * need to be processed differently on these
+				 * two platforms */
 {
     Tcl_Obj **globList = NULL, **ostypeList = NULL;
     int globCount, ostypeCount, i, code = TCL_OK;
@@ -215,38 +218,44 @@ AddClause(interp, filterPtr, patternsObj, ostypesObj, isWindows)
 	    code = TCL_ERROR;
 	    goto done;
 	}
+
 	/*
 	 * We probably need this encoding now...
 	 */
+
 	macRoman = Tcl_GetEncoding(NULL, "macRoman");
 
-	/* 
-	 * Might be cleaner to use 'Tcl_GetOSTypeFromObj' but that is
-	 * actually static to the MacOS X/Darwin version of Tcl, and
-	 * would therefore require further code refactoring.
+	/*
+	 * Might be cleaner to use 'Tcl_GetOSTypeFromObj' but that is actually
+	 * static to the MacOS X/Darwin version of Tcl, and would therefore
+	 * require further code refactoring.
 	 */
+
 	for (i=0; i<ostypeCount; i++) {
 	    int len;
 	    CONST char *strType = Tcl_GetStringFromObj(ostypeList[i], &len);
-	    /* 
-	     * If len is < 4, it is definitely an error.  If equal or
-	     * longer, we need to use the macRoman encoding to determine
-	     * the correct length (assuming there may be non-ascii
-	     * characters, eg., embedded nulls or accented characters in
-	     * the string, the macRoman length will be different).
+
+	    /*
+	     * If len is < 4, it is definitely an error. If equal or longer,
+	     * we need to use the macRoman encoding to determine the correct
+	     * length (assuming there may be non-ascii characters, e.g.,
+	     * embedded nulls or accented characters in the string, the
+	     * macRoman length will be different).
 	     *
-	     * If we couldn't load the encoding, then we can't
-	     * actually check the correct length.  But here we assume
-	     * we're probably operating on unix/windows with a minimal
-	     * set of encodings and so don't care about MacOS types.
-	     * So we won't signal an error.
+	     * If we couldn't load the encoding, then we can't actually check
+	     * the correct length. But here we assume we're probably operating
+	     * on unix/windows with a minimal set of encodings and so don't
+	     * care about MacOS types. So we won't signal an error.
 	     */
+
 	    if (len >= 4 && macRoman != NULL) {
 		Tcl_DString osTypeDS;
-		/* 
-		 * Convert utf to macRoman, since MacOS types are
-		 * defined to be 4 macRoman characters long
+
+		/*
+		 * Convert utf to macRoman, since MacOS types are defined to
+		 * be 4 macRoman characters long
 		 */
+
 		Tcl_UtfToExternalDString(macRoman, strType, len, &osTypeDS);
 		len = Tcl_DStringLength(&osTypeDS);
 		Tcl_DStringFree(&osTypeDS);
@@ -261,7 +270,7 @@ AddClause(interp, filterPtr, patternsObj, ostypesObj, isWindows)
     }
 
     /*
-     * Add the clause into the list of clauses 
+     * Add the clause into the list of clauses
      */
 
     clausePtr = (FileFilterClause*)ckalloc(sizeof(FileFilterClause));
@@ -290,6 +299,7 @@ AddClause(interp, filterPtr, patternsObj, ostypesObj, isWindows)
 		/*
 		 * Prepend a "*" to patterns that do not have a leading "*"
 		 */
+
 		globPtr->pattern = (char*)ckalloc((unsigned int) len+1);
 		globPtr->pattern[0] = '*';
 		strcpy(globPtr->pattern+1, str);
@@ -303,14 +313,15 @@ AddClause(interp, filterPtr, patternsObj, ostypesObj, isWindows)
 		     * extensions"
 		     * BUG: "*." actually matches with all files on Win95
 		     */
-		    globPtr->pattern = (char*)ckalloc(3 * sizeof(char));
+
+		    globPtr->pattern = (char *) ckalloc(3 * sizeof(char));
 		    strcpy(globPtr->pattern, "*.");
 		} else {
-		    globPtr->pattern = (char*)ckalloc((unsigned int) len);
+		    globPtr->pattern = (char *) ckalloc((unsigned int) len);
 		    strcpy(globPtr->pattern, str);
 		}
 	    } else {
-		globPtr->pattern = (char*)ckalloc((unsigned int) len);
+		globPtr->pattern = (char *) ckalloc((unsigned int) len);
 		strcpy(globPtr->pattern, str);
 	    }
 
@@ -337,10 +348,11 @@ AddClause(interp, filterPtr, patternsObj, ostypesObj, isWindows)
 	    MacFileType *mfPtr = (MacFileType *) ckalloc(sizeof(MacFileType));
 	    CONST char *strType = Tcl_GetStringFromObj(ostypeList[i], &len);
 
-	    /* 
-	     * Convert utf to macRoman, since MacOS types are 
-	     * defined to be 4 macRoman characters long
+	    /*
+	     * Convert utf to macRoman, since MacOS types are defined to be 4
+	     * macRoman characters long
 	     */
+
 	    Tcl_UtfToExternalDString(macRoman, strType, len, &osTypeDS);
 
 	    memcpy(&mfPtr->type, Tcl_DStringValue(&osTypeDS), sizeof(OSType));
@@ -349,6 +361,7 @@ AddClause(interp, filterPtr, patternsObj, ostypesObj, isWindows)
 	    /*
 	     * Add the Mac type pattern into the list of Mac types
 	     */
+
 	    if (clausePtr->macTypes == NULL) {
 		clausePtr->macTypes = clausePtr->macTypesTail = mfPtr;
 	    } else {
@@ -360,12 +373,11 @@ AddClause(interp, filterPtr, patternsObj, ostypesObj, isWindows)
     }
 
   done:
-
     if (macRoman != NULL) {
 	Tcl_FreeEncoding(macRoman);
     }
     return code;
-}	
+}
 
 /*
  *----------------------------------------------------------------------
@@ -379,14 +391,15 @@ AddClause(interp, filterPtr, patternsObj, ostypesObj, isWindows)
  *
  * Side effects:
  *	The list of filters are updated in flistPtr.
+ *
  *----------------------------------------------------------------------
  */
 
 static FileFilter *
-GetFilter(flistPtr, name)
-    FileFilterList *flistPtr;	/* The FileFilterList that contains the
-				 * newly created filter */
-    CONST char *name;		/* Name of the filter. It is usually displayed
+GetFilter(
+    FileFilterList *flistPtr,	/* The FileFilterList that contains the newly
+				 * created filter */
+    CONST char *name)		/* Name of the filter. It is usually displayed
 				 * in the "File Types" listbox in the file
 				 * dialogs. */
 {
@@ -428,12 +441,13 @@ GetFilter(flistPtr, name)
  *
  * Side effects:
  *	The list of clauses in filterPtr->clauses are freed.
+ *
  *----------------------------------------------------------------------
  */
 
 static void
-FreeClauses(filterPtr)
-    FileFilter * filterPtr;	/* FileFilter whose clauses are to be freed */
+FreeClauses(
+    FileFilter *filterPtr)	/* FileFilter whose clauses are to be freed */
 {
     FileFilterClause *clausePtr = filterPtr->clauses;
 
@@ -461,12 +475,13 @@ FreeClauses(filterPtr)
  *
  * Side effects:
  *	The list of glob patterns in clausePtr->patterns are freed.
+ *
  *----------------------------------------------------------------------
  */
 
 static void
-FreeGlobPatterns(clausePtr)
-    FileFilterClause * clausePtr;/* The clause whose patterns are to be freed*/
+FreeGlobPatterns(
+    FileFilterClause *clausePtr)/* The clause whose patterns are to be freed*/
 {
     GlobPattern *globPtr = clausePtr->patterns;
 
@@ -492,13 +507,14 @@ FreeGlobPatterns(clausePtr)
  *
  * Side effects:
  *	The list of Mac file types in clausePtr->macTypes are freed.
+ *
  *----------------------------------------------------------------------
  */
 
 static void
-FreeMacFileTypes(clausePtr)
-    FileFilterClause * clausePtr;  /* The clause whose mac types are to be
-				    * freed */
+FreeMacFileTypes(
+    FileFilterClause *clausePtr)/* The clause whose mac types are to be
+				 * freed */
 {
     MacFileType *mfPtr = clausePtr->macTypes;
 
@@ -509,3 +525,11 @@ FreeMacFileTypes(clausePtr)
     }
     clausePtr->macTypes = NULL;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */