More bits of ANSIfying

1 files changed, 230 insertions, 229 deletions

diff --git a/generic/tkCursor.c b/generic/tkCursor.c
index 45dd96d..11c0ace 100644
--- a/generic/tkCursor.c
+++ b/generic/tkCursor.c
@@ -1,54 +1,53 @@
-/* 
+/*
  * tkCursor.c --
  *
  *	This file maintains a database of read-only cursors for the Tk
- *	toolkit.  This allows cursors to be shared between widgets and
- *	also avoids round-trips to the X server.
+ *	toolkit. This allows cursors to be shared between widgets and also
+ *	avoids round-trips to the X server.
  *
  * 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: tkCursor.c,v 1.12 2004/09/24 17:36:22 dgp Exp $
+ * RCS: @(#) $Id: tkCursor.c,v 1.13 2005/11/11 23:51:27 dkf Exp $
  */
 
 #include "tkPort.h"
 #include "tkInt.h"
 
 /*
- * A TkCursor structure exists for each cursor that is currently
- * active.  Each structure is indexed with two hash tables defined
- * below.  One of the tables is cursorIdTable, and the other is either
- * cursorNameTable or cursorDataTable, each of which are stored in the
- * TkDisplay structure for the current thread.
+ * A TkCursor structure exists for each cursor that is currently active. Each
+ * structure is indexed with two hash tables defined below. One of the tables
+ * is cursorIdTable, and the other is either cursorNameTable or
+ * cursorDataTable, each of which are stored in the TkDisplay structure for
+ * the current thread.
  */
 
 typedef struct {
     CONST char *source;		/* Cursor bits. */
     CONST char *mask;		/* Mask bits. */
-    int width, height;		/* Dimensions of cursor (and data
-				 * and mask). */
+    int width, height;		/* Dimensions of cursor (and data and
+				 * mask). */
     int xHot, yHot;		/* Location of cursor hot-spot. */
     Tk_Uid fg, bg;		/* Colors for cursor. */
     Display *display;		/* Display on which cursor will be used. */
 } DataKey;
 
 /*
- * Forward declarations for procedures defined in this file:
+ * Forward declarations for functions defined in this file:
  */
 
-static void		CursorInit _ANSI_ARGS_((TkDisplay *dispPtr));
-static void		DupCursorObjProc _ANSI_ARGS_((Tcl_Obj *srcObjPtr,
-			    Tcl_Obj *dupObjPtr));
-static void		FreeCursor _ANSI_ARGS_((TkCursor *cursorPtr));
-static void		FreeCursorObjProc _ANSI_ARGS_((Tcl_Obj *objPtr));
-static TkCursor *	TkcGetCursor _ANSI_ARGS_((Tcl_Interp *interp,
-			    Tk_Window tkwin, CONST char *name));
-static TkCursor *	GetCursorFromObj _ANSI_ARGS_((Tk_Window tkwin,
-			    Tcl_Obj *objPtr));
-static void		InitCursorObj _ANSI_ARGS_((Tcl_Obj *objPtr));
+static void		CursorInit(TkDisplay *dispPtr);
+static void		DupCursorObjProc(Tcl_Obj *srcObjPtr,
+			    Tcl_Obj *dupObjPtr);
+static void		FreeCursor(TkCursor *cursorPtr);
+static void		FreeCursorObjProc(Tcl_Obj *objPtr);
+static TkCursor *	TkcGetCursor(Tcl_Interp *interp,
+			    Tk_Window tkwin, CONST char *name);
+static TkCursor *	GetCursorFromObj(Tk_Window tkwin, Tcl_Obj *objPtr);
+static void		InitCursorObj(Tcl_Obj *objPtr);
 
 /*
  * The following structure defines the implementation of the "cursor" Tcl
@@ -71,33 +70,32 @@ Tcl_ObjType tkCursorObjType = {
  *
  * Tk_AllocCursorFromObj --
  *
- *	Given a Tcl_Obj *, map the value to a corresponding
- *	Tk_Cursor structure based on the tkwin given.
+ *	Given a Tcl_Obj *, map the value to a corresponding Tk_Cursor
+ *	structure based on the tkwin given.
  *
  * Results:
- *	The return value is the X identifer for the desired cursor,
- *	unless objPtr 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 cursor that is returned, and
- *	should eventually call Tk_FreeCursorFromObj when the cursor is no 
- *	longer needed.
+ *	The return value is the X identifer for the desired cursor, unless
+ *	objPtr 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 cursor that is returned, and should eventually call
+ *	Tk_FreeCursorFromObj when the cursor is no longer needed.
  *
  * Side effects:
  *	The cursor is added to an internal database with a reference count.
- *	For each call to this procedure, there should eventually be a call
- *	to Tk_FreeCursorFromObj, so that the database can be cleaned up 
- *	when cursors aren't needed anymore.
+ *	For each call to this function, there should eventually be a call to
+ *	Tk_FreeCursorFromObj, so that the database can be cleaned up when
+ *	cursors aren't needed anymore.
  *
  *----------------------------------------------------------------------
  */
 
 Tk_Cursor
-Tk_AllocCursorFromObj(interp, tkwin, objPtr)
-    Tcl_Interp *interp;		/* Interp for error results. */
-    Tk_Window tkwin;		/* Window in which the cursor will be used.*/
-    Tcl_Obj *objPtr;		/* Object describing cursor; see manual
-				 * entry for description of legal
-				 * syntax of this obj's string rep. */
+Tk_AllocCursorFromObj(
+    Tcl_Interp *interp,		/* Interp for error results. */
+    Tk_Window tkwin,		/* Window in which the cursor will be used.*/
+    Tcl_Obj *objPtr)		/* Object describing cursor; see manual entry
+				 * for description of legal syntax of this
+				 * obj's string rep. */
 {
     TkCursor *cursorPtr;
 
@@ -107,16 +105,17 @@ Tk_AllocCursorFromObj(interp, tkwin, objPtr)
     cursorPtr = (TkCursor *) objPtr->internalRep.twoPtrValue.ptr1;
 
     /*
-     * If the object currently points to a TkCursor, see if it's the
-     * one we want.  If so, increment its reference count and return.
+     * If the object currently points to a TkCursor, see if it's the one we
+     * want. If so, increment its reference count and return.
      */
 
     if (cursorPtr != NULL) {
 	if (cursorPtr->resourceRefCount == 0) {
 	    /*
-	     * This is a stale reference: it refers to a TkCursor that's
-	     * no longer in use.  Clear the reference.
+	     * This is a stale reference: it refers to a TkCursor that's no
+	     * longer in use. Clear the reference.
 	     */
+
 	    FreeCursorObjProc(objPtr);
 	    cursorPtr = NULL;
 	} else if (Tk_Display(tkwin) == cursorPtr->display) {
@@ -126,38 +125,37 @@ Tk_AllocCursorFromObj(interp, tkwin, objPtr)
     }
 
     /*
-     * The object didn't point to the TkCursor that we wanted.  Search
-     * the list of TkCursors with the same name to see if one of the
-     * other TkCursors is the right one.
+     * The object didn't point to the TkCursor that we wanted. Search the list
+     * of TkCursors with the same name to see if one of the other TkCursors is
+     * the right one.
      */
 
     if (cursorPtr != NULL) {
-	TkCursor *firstCursorPtr =
-		(TkCursor *) Tcl_GetHashValue(cursorPtr->hashPtr);
+	TkCursor *firstCursorPtr = (TkCursor *)
+		Tcl_GetHashValue(cursorPtr->hashPtr);
 	FreeCursorObjProc(objPtr);
 	for (cursorPtr = firstCursorPtr;  cursorPtr != NULL;
 		cursorPtr = cursorPtr->nextPtr) {
 	    if (Tk_Display(tkwin) == cursorPtr->display) {
 		cursorPtr->resourceRefCount++;
 		cursorPtr->objRefCount++;
-		objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) cursorPtr;
+		objPtr->internalRep.twoPtrValue.ptr1 = (void *) cursorPtr;
 		return cursorPtr->cursor;
 	    }
 	}
     }
 
     /*
-     * Still no luck.  Call TkcGetCursor to allocate a new TkCursor object.
+     * Still no luck. Call TkcGetCursor to allocate a new TkCursor object.
      */
 
     cursorPtr = TkcGetCursor(interp, tkwin, Tcl_GetString(objPtr));
-    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) cursorPtr;
+    objPtr->internalRep.twoPtrValue.ptr1 = (void *) cursorPtr;
     if (cursorPtr == NULL) {
 	return None;
-    } else {
-	cursorPtr->objRefCount++;
-	return cursorPtr->cursor;
     }
+    cursorPtr->objRefCount++;
+    return cursorPtr->cursor;
 }
 
 /*
@@ -165,32 +163,31 @@ Tk_AllocCursorFromObj(interp, tkwin, objPtr)
  *
  * Tk_GetCursor --
  *
- *	Given a string describing a cursor, locate (or create if necessary)
- *	a cursor that fits the description.
+ *	Given a string describing a cursor, locate (or create if necessary) a
+ *	cursor that fits the description.
  *
  * Results:
- *	The return value is the X identifer for the desired cursor,
- *	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 cursor that is returned, and
- *	should eventually call Tk_FreeCursor when the cursor is no longer
- *	needed.
+ *	The return value is the X identifer for the desired cursor, 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 cursor that is returned, and should eventually call
+ *	Tk_FreeCursor when the cursor is no longer needed.
  *
  * Side effects:
  *	The cursor is added to an internal database with a reference count.
- *	For each call to this procedure, there should eventually be a call
- *	to Tk_FreeCursor, so that the database can be cleaned up when cursors
+ *	For each call to this function, there should eventually be a call to
+ *	Tk_FreeCursor, so that the database can be cleaned up when cursors
  *	aren't needed anymore.
  *
  *----------------------------------------------------------------------
  */
 
 Tk_Cursor
-Tk_GetCursor(interp, tkwin, string)
-    Tcl_Interp *interp;		/* Interpreter to use for error reporting. */
-    Tk_Window tkwin;		/* Window in which cursor will be used. */
-    Tk_Uid string;		/* Description of cursor.  See manual entry
-				 * for details on legal syntax. */
+Tk_GetCursor(
+    Tcl_Interp *interp,		/* Interpreter to use for error reporting. */
+    Tk_Window tkwin,		/* Window in which cursor will be used. */
+    Tk_Uid string)		/* Description of cursor. See manual entry for
+				 * details on legal syntax. */
 {
     TkCursor *cursorPtr = TkcGetCursor(interp, tkwin, string);
     if (cursorPtr == NULL) {
@@ -204,34 +201,33 @@ Tk_GetCursor(interp, tkwin, string)
  *
  * TkcGetCursor --
  *
- *	Given a string describing a cursor, locate (or create if necessary)
- *	a cursor that fits the description. This routine returns the
- *	internal data structure for the cursor, which avoids extra
- *	hash table lookups in Tk_AllocCursorFromObj.
+ *	Given a string describing a cursor, locate (or create if necessary) a
+ *	cursor that fits the description. This routine returns the internal
+ *	data structure for the cursor, which avoids extra hash table lookups
+ *	in Tk_AllocCursorFromObj.
  *
  * Results:
- *	The return value is a pointer to the TkCursor for the desired
- *	cursor, unless string couldn't be parsed correctly.  In this
- *	case, NULL is returned and an error message is left in the
- *	interp's result. The caller should never modify the cursor that
- *	is returned, and should eventually call Tk_FreeCursor when the
- *	cursor is no longer needed.
+ *	The return value is a pointer to the TkCursor for the desired cursor,
+ *	unless string couldn't be parsed correctly. In this case, NULL is
+ *	returned and an error message is left in the interp's result. The
+ *	caller should never modify the cursor that is returned, and should
+ *	eventually call Tk_FreeCursor when the cursor is no longer needed.
  *
  * Side effects:
  *	The cursor is added to an internal database with a reference count.
- *	For each call to this procedure, there should eventually be a call
- *	to Tk_FreeCursor, so that the database can be cleaned up when cursors
+ *	For each call to this function, there should eventually be a call to
+ *	Tk_FreeCursor, so that the database can be cleaned up when cursors
  *	aren't needed anymore.
  *
  *----------------------------------------------------------------------
  */
 
 static TkCursor *
-TkcGetCursor(interp, tkwin, string)
-    Tcl_Interp *interp;		/* Interpreter to use for error reporting. */
-    Tk_Window tkwin;		/* Window in which cursor will be used. */
-    CONST char *string;		/* Description of cursor.  See manual entry
-				 * for details on legal syntax. */
+TkcGetCursor(
+    Tcl_Interp *interp,		/* Interpreter to use for error reporting. */
+    Tk_Window tkwin,		/* Window in which cursor will be used. */
+    CONST char *string)		/* Description of cursor. See manual entry for
+				 * details on legal syntax. */
 {
     Tcl_HashEntry *nameHashPtr;
     register TkCursor *cursorPtr;
@@ -243,7 +239,7 @@ TkcGetCursor(interp, tkwin, string)
 	CursorInit(dispPtr);
     }
 
-    nameHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorNameTable, 
+    nameHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorNameTable,
             string, &new);
     if (!new) {
 	existingCursorPtr = (TkCursor *) Tcl_GetHashValue(nameHashPtr);
@@ -277,7 +273,7 @@ TkcGetCursor(interp, tkwin, string)
     cursorPtr->otherTable = &dispPtr->cursorNameTable;
     cursorPtr->hashPtr = nameHashPtr;
     cursorPtr->nextPtr = existingCursorPtr;
-    cursorPtr->idHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorIdTable, 
+    cursorPtr->idHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorIdTable,
             (char *) cursorPtr->cursor, &new);
     if (!new) {
 	Tcl_Panic("cursor already registered in Tk_GetCursor");
@@ -293,37 +289,35 @@ TkcGetCursor(interp, tkwin, string)
  *
  * Tk_GetCursorFromData --
  *
- *	Given a description of the bits and colors for a cursor,
- *	make a cursor that has the given properties.
+ *	Given a description of the bits and colors for a cursor, make a cursor
+ *	that has the given properties.
  *
  * Results:
- *	The return value is the X identifer for the desired cursor,
- *	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 cursor that is returned, and
- *	should eventually call Tk_FreeCursor when the cursor is no
- *	longer needed.
+ *	The return value is the X identifer for the desired cursor, 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 cursor that is returned, and should eventually call
+ *	Tk_FreeCursor when the cursor is no longer needed.
  *
  * Side effects:
  *	The cursor is added to an internal database with a reference count.
- *	For each call to this procedure, there should eventually be a call
- *	to Tk_FreeCursor, so that the database can be cleaned up when cursors
+ *	For each call to this function, there should eventually be a call to
+ *	Tk_FreeCursor, so that the database can be cleaned up when cursors
  *	aren't needed anymore.
  *
  *----------------------------------------------------------------------
  */
 
 Tk_Cursor
-Tk_GetCursorFromData(interp, tkwin, source, mask, width, height,
-	xHot, yHot, fg, bg)
-    Tcl_Interp *interp;		/* Interpreter to use for error reporting. */
-    Tk_Window tkwin;		/* Window in which cursor will be used. */
-    CONST char *source;		/* Bitmap data for cursor shape. */
-    CONST char *mask;		/* Bitmap data for cursor mask. */
-    int width, height;		/* Dimensions of cursor. */
-    int xHot, yHot;		/* Location of hot-spot in cursor. */
-    Tk_Uid fg;			/* Foreground color for cursor. */
-    Tk_Uid bg;			/* Background color for cursor. */
+Tk_GetCursorFromData(
+    Tcl_Interp *interp,		/* Interpreter to use for error reporting. */
+    Tk_Window tkwin,		/* Window in which cursor will be used. */
+    CONST char *source,		/* Bitmap data for cursor shape. */
+    CONST char *mask,		/* Bitmap data for cursor mask. */
+    int width, int height,	/* Dimensions of cursor. */
+    int xHot, int yHot,		/* Location of hot-spot in cursor. */
+    Tk_Uid fg,			/* Foreground color for cursor. */
+    Tk_Uid bg)			/* Background color for cursor. */
 {
     DataKey dataKey;
     Tcl_HashEntry *dataHashPtr;
@@ -332,7 +326,6 @@ Tk_GetCursorFromData(interp, tkwin, source, mask, width, height,
     XColor fgColor, bgColor;
     TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
 
-
     if (!dispPtr->cursorInit) {
 	CursorInit(dispPtr);
     }
@@ -346,7 +339,7 @@ Tk_GetCursorFromData(interp, tkwin, source, mask, width, height,
     dataKey.fg = fg;
     dataKey.bg = bg;
     dataKey.display = Tk_Display(tkwin);
-    dataHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorDataTable, 
+    dataHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorDataTable,
             (char *) &dataKey, &new);
     if (!new) {
 	cursorPtr = (TkCursor *) Tcl_GetHashValue(dataHashPtr);
@@ -355,18 +348,16 @@ Tk_GetCursorFromData(interp, tkwin, source, mask, width, height,
     }
 
     /*
-     * No suitable cursor exists yet.  Make one using the data
-     * available and add it to the database.
+     * No suitable cursor exists yet. Make one using the data available and
+     * add it to the database.
      */
 
     if (XParseColor(dataKey.display, Tk_Colormap(tkwin), fg, &fgColor) == 0) {
-	Tcl_AppendResult(interp, "invalid color name \"", fg, "\"",
-		(char *) NULL);
+	Tcl_AppendResult(interp, "invalid color name \"", fg, "\"", NULL);
 	goto error;
     }
     if (XParseColor(dataKey.display, Tk_Colormap(tkwin), bg, &bgColor) == 0) {
-	Tcl_AppendResult(interp, "invalid color name \"", bg, "\"",
-		(char *) NULL);
+	Tcl_AppendResult(interp, "invalid color name \"", bg, "\"", NULL);
 	goto error;
     }
 
@@ -381,7 +372,7 @@ Tk_GetCursorFromData(interp, tkwin, source, mask, width, height,
     cursorPtr->otherTable = &dispPtr->cursorDataTable;
     cursorPtr->hashPtr = dataHashPtr;
     cursorPtr->objRefCount = 0;
-    cursorPtr->idHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorIdTable, 
+    cursorPtr->idHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorIdTable,
             (char *) cursorPtr->cursor, &new);
     cursorPtr->nextPtr = NULL;
 
@@ -392,7 +383,7 @@ Tk_GetCursorFromData(interp, tkwin, source, mask, width, height,
     Tcl_SetHashValue(cursorPtr->idHashPtr, cursorPtr);
     return cursorPtr->cursor;
 
-    error:
+  error:
     Tcl_DeleteHashEntry(dataHashPtr);
     return None;
 }
@@ -405,12 +396,11 @@ Tk_GetCursorFromData(interp, tkwin, source, mask, width, height,
  *	Given a cursor, return a textual string identifying it.
  *
  * Results:
- *	If cursor was created by Tk_GetCursor, then the return
- *	value is the "string" that was used to create it.
- *	Otherwise the return value is a string giving the X
- *	identifier for the cursor.  The storage for the returned
- *	string is only guaranteed to persist up until the next
- *	call to this procedure.
+ *	If cursor was created by Tk_GetCursor, then the return value is the
+ *	"string" that was used to create it. Otherwise the return value is a
+ *	string giving the X identifier for the cursor. The storage for the
+ *	returned string is only guaranteed to persist up until the next call
+ *	to this function.
  *
  * Side effects:
  *	None.
@@ -419,9 +409,9 @@ Tk_GetCursorFromData(interp, tkwin, source, mask, width, height,
  */
 
 CONST char *
-Tk_NameOfCursor(display, cursor)
-    Display *display;		/* Display for which cursor was allocated. */
-    Tk_Cursor cursor;		/* Identifier for cursor whose name is
+Tk_NameOfCursor(
+    Display *display,		/* Display for which cursor was allocated. */
+    Tk_Cursor cursor)		/* Identifier for cursor whose name is
 				 * wanted. */
 {
     Tcl_HashEntry *idHashPtr;
@@ -431,8 +421,8 @@ Tk_NameOfCursor(display, cursor)
     dispPtr = TkGetDisplay(display);
 
     if (!dispPtr->cursorInit) {
-	printid:
-	sprintf(dispPtr->cursorString, "cursor id 0x%x", 
+    printid:
+	sprintf(dispPtr->cursorString, "cursor id 0x%x",
                 (unsigned int) cursor);
 	return dispPtr->cursorString;
     }
@@ -452,23 +442,22 @@ Tk_NameOfCursor(display, cursor)
  *
  * FreeCursor --
  *
- *	This procedure is invoked by both Tk_FreeCursor and
- *	Tk_FreeCursorFromObj; it does all the real work of deallocating
- *	a cursor.
+ *	This function is invoked by both Tk_FreeCursorFromObj and
+ *	Tk_FreeCursor; it does all the real work of deallocating a cursor.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The reference count associated with cursor is decremented, and
- *	it is officially deallocated if no-one is using it anymore.
+ *	The reference count associated with cursor is decremented, and it is
+ *	officially deallocated if no-one is using it anymore.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-FreeCursor(cursorPtr)
-    TkCursor *cursorPtr;	/* Cursor to be released. */
+FreeCursor(
+    TkCursor *cursorPtr)	/* Cursor to be released. */
 {
     TkCursor *prevPtr;
 
@@ -502,23 +491,23 @@ FreeCursor(cursorPtr)
  *
  * Tk_FreeCursor --
  *
- *	This procedure is called to release a cursor allocated by
- *	Tk_GetCursor or TkGetCursorFromData.
+ *	This function is called to release a cursor allocated by Tk_GetCursor
+ *	or TkGetCursorFromData.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The reference count associated with cursor is decremented, and
- *	it is officially deallocated if no-one is using it anymore.
+ *	The reference count associated with cursor is decremented, and it is
+ *	officially deallocated if no-one is using it anymore.
  *
  *----------------------------------------------------------------------
  */
 
 void
-Tk_FreeCursor(display, cursor)
-    Display *display;		/* Display for which cursor was allocated. */
-    Tk_Cursor cursor;		/* Identifier for cursor to be released. */
+Tk_FreeCursor(
+    Display *display,		/* Display for which cursor was allocated. */
+    Tk_Cursor cursor)		/* Identifier for cursor to be released. */
 {
     Tcl_HashEntry *idHashPtr;
     TkDisplay *dispPtr = TkGetDisplay(display);
@@ -539,27 +528,27 @@ Tk_FreeCursor(display, cursor)
  *
  * Tk_FreeCursorFromObj --
  *
- *	This procedure is called to release a cursor allocated by
- *	Tk_AllocCursorFromObj. It does not throw away the Tcl_Obj *;
- *	it only gets rid of the hash table entry for this cursor
- *	and clears the cached value that is normally stored in the object.
+ *	This function is called to release a cursor allocated by
+ *	Tk_AllocCursorFromObj. It does not throw away the Tcl_Obj *; it only
+ *	gets rid of the hash table entry for this cursor and clears the cached
+ *	value that is normally stored in the object.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The reference count associated with the cursor represented by
- *	objPtr is decremented, and the cursor is released to X if there are 
- *	no remaining uses for it.
+ *	The reference count associated with the cursor represented by objPtr
+ *	is decremented, and the cursor is released to X if there are no
+ *	remaining uses for it.
  *
  *----------------------------------------------------------------------
  */
 
 void
-Tk_FreeCursorFromObj(tkwin, objPtr)
-    Tk_Window tkwin;		/* The window this cursor lives in. Needed
-				 * for the display value. */
-    Tcl_Obj *objPtr;		/* The Tcl_Obj * to be freed. */
+Tk_FreeCursorFromObj(
+    Tk_Window tkwin,		/* The window this cursor lives in. Needed for
+				 * the display value. */
+    Tcl_Obj *objPtr)		/* The Tcl_Obj * to be freed. */
 {
     FreeCursor(GetCursorFromObj(tkwin, objPtr));
     FreeCursorObjProc(objPtr);
@@ -568,66 +557,65 @@ Tk_FreeCursorFromObj(tkwin, objPtr)
 /*
  *---------------------------------------------------------------------------
  *
- * FreeCursorFromObjProc -- 
+ * FreeCursorFromObjProc --
  *
  *	This proc is called to release an object reference to a cursor.
- *	Called when the object's internal rep is released or when
- *	the cached tkColPtr needs to be changed.
+ *	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
-FreeCursorObjProc(objPtr)
-    Tcl_Obj *objPtr;		/* The object we are releasing. */
+FreeCursorObjProc(
+    Tcl_Obj *objPtr)		/* The object we are releasing. */
 {
     TkCursor *cursorPtr = (TkCursor *) objPtr->internalRep.twoPtrValue.ptr1;
 
     if (cursorPtr != NULL) {
 	cursorPtr->objRefCount--;
-	if ((cursorPtr->objRefCount == 0) 
+	if ((cursorPtr->objRefCount == 0)
 		&& (cursorPtr->resourceRefCount == 0)) {
 	    ckfree((char *) cursorPtr);
 	}
-	objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) NULL;
+	objPtr->internalRep.twoPtrValue.ptr1 = NULL;
     }
 }
 
 /*
  *---------------------------------------------------------------------------
  *
- * DupCursorObjProc -- 
+ * DupCursorObjProc --
  *
- *	When a cached cursor object is duplicated, this is called to
- *	update the internal reps.
+ *	When a cached cursor 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
-DupCursorObjProc(srcObjPtr, dupObjPtr)
-    Tcl_Obj *srcObjPtr;		/* The object we are copying from. */
-    Tcl_Obj *dupObjPtr;		/* The object we are copying to. */
+DupCursorObjProc(
+    Tcl_Obj *srcObjPtr,		/* The object we are copying from. */
+    Tcl_Obj *dupObjPtr)		/* The object we are copying to. */
 {
     TkCursor *cursorPtr = (TkCursor *) srcObjPtr->internalRep.twoPtrValue.ptr1;
-    
+
     dupObjPtr->typePtr = srcObjPtr->typePtr;
-    dupObjPtr->internalRep.twoPtrValue.ptr1 = (VOID *) cursorPtr;
+    dupObjPtr->internalRep.twoPtrValue.ptr1 = (void *) cursorPtr;
 
     if (cursorPtr != NULL) {
 	cursorPtr->objRefCount++;
@@ -640,27 +628,31 @@ DupCursorObjProc(srcObjPtr, dupObjPtr)
  * Tk_GetCursorFromObj --
  *
  *	Returns the cursor referred to buy a Tcl object. The cursor must
- *	already have been allocated via a call to Tk_AllocCursorFromObj or 
+ *	already have been allocated via a call to Tk_AllocCursorFromObj or
  *	Tk_GetCursor.
  *
  * Results:
- *	Returns the Tk_Cursor that matches the tkwin and the string rep
- *	of the name of the cursor given in objPtr.
+ *	Returns the Tk_Cursor that matches the tkwin and the string rep of the
+ *	name of the cursor given in objPtr.
  *
  * Side effects:
- *	If the object is not already a cursor, the conversion will free
- *	any old internal representation. 
+ *	If the object is not already a cursor, the conversion will free any
+ *	old internal representation.
  *
  *----------------------------------------------------------------------
  */
 
 Tk_Cursor
-Tk_GetCursorFromObj(tkwin, objPtr)
-    Tk_Window tkwin;
-    Tcl_Obj *objPtr;		/* The object from which to get pixels. */
+Tk_GetCursorFromObj(
+    Tk_Window tkwin,
+    Tcl_Obj *objPtr)		/* The object from which to get pixels. */
 {
     TkCursor *cursorPtr = GetCursorFromObj(tkwin, objPtr);
-    /* GetCursorFromObj should never return NULL */
+
+    /*
+     * GetCursorFromObj should never return NULL
+     */
+
     return cursorPtr->cursor;
 }
 
@@ -669,25 +661,25 @@ Tk_GetCursorFromObj(tkwin, objPtr)
  *
  * GetCursorFromObj --
  *
- *	Returns the cursor referred to by a Tcl object.  The cursor must
- *	already have been allocated via a call to Tk_AllocCursorFromObj
- *	or Tk_GetCursor.
+ *	Returns the cursor referred to by a Tcl object. The cursor must
+ *	already have been allocated via a call to Tk_AllocCursorFromObj or
+ *	Tk_GetCursor.
  *
  * Results:
- *	Returns the TkCursor * that matches the tkwin and the string rep
- *	of the name of the cursor given in objPtr.
+ *	Returns the TkCursor * that matches the tkwin and the string rep of
+ *	the name of the cursor given in objPtr.
  *
  * Side effects:
- *	If the object is not already a cursor, the conversion will free
- *	any old internal representation. 
+ *	If the object is not already a cursor, the conversion will free any
+ *	old internal representation.
  *
  *----------------------------------------------------------------------
  */
 
 static TkCursor *
-GetCursorFromObj(tkwin, objPtr)
-    Tk_Window tkwin;		/* Window in which the cursor will be used. */
-    Tcl_Obj *objPtr;		/* The object that describes the desired
+GetCursorFromObj(
+    Tk_Window tkwin,		/* Window in which the cursor will be used. */
+    Tcl_Obj *objPtr)		/* The object that describes the desired
 				 * cursor. */
 {
     TkCursor *cursorPtr;
@@ -699,11 +691,12 @@ GetCursorFromObj(tkwin, objPtr)
     }
 
     /*
-     * The internal representation is a cache of the last cursor used
-     * with the given name.  But there can be lots different cursors
-     * for each cursor name; one cursor for each display.  Check to
-     * see if the cursor we have cached is the one that is needed.
+     * The internal representation is a cache of the last cursor used with the
+     * given name. But there can be lots different cursors for each cursor
+     * name; one cursor for each display. Check to see if the cursor we have
+     * cached is the one that is needed.
      */
+
     cursorPtr = (TkCursor *) objPtr->internalRep.twoPtrValue.ptr1;
     if ((cursorPtr != NULL) && (Tk_Display(tkwin) == cursorPtr->display)) {
 	return cursorPtr;
@@ -723,13 +716,13 @@ GetCursorFromObj(tkwin, objPtr)
 	    cursorPtr != NULL; cursorPtr = cursorPtr->nextPtr) {
 	if (Tk_Display(tkwin) == cursorPtr->display) {
 	    FreeCursorObjProc(objPtr);
-	    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) cursorPtr;
+	    objPtr->internalRep.twoPtrValue.ptr1 = (void *) cursorPtr;
 	    cursorPtr->objRefCount++;
 	    return cursorPtr;
 	}
     }
 
-    error:
+  error:
     Tcl_Panic("GetCursorFromObj called with non-existent cursor!");
     /*
      * The following code isn't reached; it's just there to please compilers.
@@ -742,27 +735,27 @@ GetCursorFromObj(tkwin, objPtr)
  *
  * InitCursorObj --
  *
- *	Bookeeping procedure to change an objPtr to a cursor type.
+ *	Bookeeping function to change an objPtr to a cursor 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_AllocCursorFromObj or GetCursorFromObj.
+ *	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_AllocCursorFromObj or GetCursorFromObj.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-InitCursorObj(objPtr)
-    Tcl_Obj *objPtr;		/* The object to convert. */
+InitCursorObj(
+    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);
@@ -771,7 +764,7 @@ InitCursorObj(objPtr)
 	(*typePtr->freeIntRepProc)(objPtr);
     }
     objPtr->typePtr = &tkCursorObjType;
-    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) NULL;
+    objPtr->internalRep.twoPtrValue.ptr1 = NULL;
 }
 
 /*
@@ -791,26 +784,26 @@ InitCursorObj(objPtr)
  */
 
 static void
-CursorInit(dispPtr)
-    TkDisplay *dispPtr;   /* Display used to store thread-specific data. */
+CursorInit(
+    TkDisplay *dispPtr)		/* Display used to store thread-specific
+				 * data. */
 {
     Tcl_InitHashTable(&dispPtr->cursorNameTable, TCL_STRING_KEYS);
     Tcl_InitHashTable(&dispPtr->cursorDataTable, 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.
      */
 
-    /* 
-     *  Old code....
-     *     Tcl_InitHashTable(&dispPtr->cursorIdTable, sizeof(Display *) 
+    /*
+     * Old code....
+     *     Tcl_InitHashTable(&dispPtr->cursorIdTable, sizeof(Display *)
      *                       /sizeof(int));
      *
-     * The comment above doesn't make sense.
-     * However, XIDs should only be 32 bits, by the definition of X,
-     * so the code above causes Tk to crash.  Here is the real code:
+     * The comment above doesn't make sense. However, XIDs should only be 32
+     * bits, by the definition of X, so the code above causes Tk to crash.
+     * Here is the real code:
      */
 
     Tcl_InitHashTable(&dispPtr->cursorIdTable, TCL_ONE_WORD_KEYS);
@@ -823,13 +816,13 @@ CursorInit(dispPtr)
  *
  * TkDebugCursor --
  *
- *	This procedure returns debugging information about a cursor.
+ *	This function returns debugging information about a cursor.
  *
  * Results:
  *	The return value is a list with one sublist for each TkCursor
- *	corresponding to "name".  Each sublist has two elements that
- *	contain the resourceRefCount and objRefCount fields from the
- *	TkCursor structure.
+ *	corresponding to "name". Each sublist has two elements that contain
+ *	the resourceRefCount and objRefCount fields from the TkCursor
+ *	structure.
  *
  * Side effects:
  *	None.
@@ -838,10 +831,10 @@ CursorInit(dispPtr)
  */
 
 Tcl_Obj *
-TkDebugCursor(tkwin, name)
-    Tk_Window tkwin;		/* The window in which the cursor will be
-				 * used (not currently used). */
-    char *name;			/* Name of the desired color. */
+TkDebugCursor(
+    Tk_Window tkwin,		/* The window in which the cursor will be used
+				 * (not currently used). */
+    char *name)			/* Name of the desired color. */
 {
     TkCursor *cursorPtr;
     Tcl_HashEntry *hashPtr;
@@ -863,9 +856,17 @@ TkDebugCursor(tkwin, name)
 	    Tcl_ListObjAppendElement(NULL, objPtr,
 		    Tcl_NewIntObj(cursorPtr->resourceRefCount));
 	    Tcl_ListObjAppendElement(NULL, objPtr,
-		    Tcl_NewIntObj(cursorPtr->objRefCount)); 
+		    Tcl_NewIntObj(cursorPtr->objRefCount));
 	    Tcl_ListObjAppendElement(NULL, resultPtr, objPtr);
 	}
     }
     return resultPtr;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */