ANSIfy

1 files changed, 215 insertions, 221 deletions

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:
+ */