Formatting Systematization

1 files changed, 782 insertions, 797 deletions

diff --git a/generic/tkCanvas.c b/generic/tkCanvas.c
index f5b3333..6cc2abf 100644
--- a/generic/tkCanvas.c
+++ b/generic/tkCanvas.c
@@ -1,18 +1,18 @@
-/* 
+/*
  * tkCanvas.c --
  *
- *	This module implements canvas widgets for the Tk toolkit.
- *	A canvas displays a background and a collection of graphical
- *	objects such as rectangles, lines, and texts.
+ *	This module implements canvas widgets for the Tk toolkit. A canvas
+ *	displays a background and a collection of graphical objects such as
+ *	rectangles, lines, and texts.
  *
  * Copyright (c) 1991-1994 The Regents of the University of California.
  * Copyright (c) 1994-1997 Sun Microsystems, Inc.
  * Copyright (c) 1998-1999 by Scriptics Corporation.
  *
- * 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: tkCanvas.c,v 1.36 2005/08/10 22:02:22 dkf Exp $
+ * RCS: @(#) $Id: tkCanvas.c,v 1.37 2005/08/18 18:36:11 dkf Exp $
  */
 
 /* #define USE_OLD_TAG_SEARCH 1 */
@@ -28,32 +28,29 @@
 
 #ifdef USE_OLD_TAG_SEARCH
 /*
- * The structure defined below is used to keep track of a tag search
- * in progress.  No field should be accessed by anyone other than
- * StartTagSearch and NextItem.
+ * The structure defined below is used to keep track of a tag search in
+ * progress. No field should be accessed by anyone other than StartTagSearch
+ * and NextItem.
  */
 
 typedef struct TagSearch {
     TkCanvas *canvasPtr;	/* Canvas widget being searched. */
-    Tk_Uid tag;			/* Tag to search for.   0 means return
-				 * all items. */
+    Tk_Uid tag;			/* Tag to search for. 0 means return all
+				 * items. */
     Tk_Item *currentPtr;	/* Pointer to last item returned. */
-    Tk_Item *lastPtr;		/* The item right before the currentPtr
-				 * is tracked so if the currentPtr is
-				 * deleted we don't have to start from the
-				 * beginning. */
+    Tk_Item *lastPtr;		/* The item right before the currentPtr is
+				 * tracked so if the currentPtr is deleted we
+				 * don't have to start from the beginning. */
     int searchOver;		/* Non-zero means NextItem should always
 				 * return NULL. */
 } TagSearch;
 
 #else /* USE_OLD_TAG_SEARCH */
 /*
- * The structure defined below is used to keep track of a tag search
- * in progress.  No field should be accessed by anyone other than
- * TagSearchScan, TagSearchFirst, TagSearchNext,
- * TagSearchScanExpr, TagSearchEvalExpr, 
- * TagSearchExprInit, TagSearchExprDestroy,
- * TagSearchDestroy.
+ * The structure defined below is used to keep track of a tag search in
+ * progress. No field should be accessed by anyone other than TagSearchScan,
+ * TagSearchFirst, TagSearchNext, TagSearchScanExpr, TagSearchEvalExpr,
+ * TagSearchExprInit, TagSearchExprDestroy, TagSearchDestroy.
  * (
  *   Not quite accurate: the TagSearch structure is also accessed from:
  *    CanvasWidgetCmd, FindItems, RelinkItems
@@ -69,23 +66,20 @@ typedef struct TagSearch {
 typedef struct TagSearch {
     TkCanvas *canvasPtr;	/* Canvas widget being searched. */
     Tk_Item *currentPtr;	/* Pointer to last item returned. */
-    Tk_Item *lastPtr;		/* The item right before the currentPtr
-				 * is tracked so if the currentPtr is
-				 * deleted we don't have to start from the
-				 * beginning. */
+    Tk_Item *lastPtr;		/* The item right before the currentPtr is
+				 * tracked so if the currentPtr is deleted we
+				 * don't have to start from the beginning. */
     int searchOver;		/* Non-zero means NextItem should always
 				 * return NULL. */
-    int type;			/* search type */
-    int id;			/* item id for searches by id */
-
-    char *string;		/* tag expression string */
-    int stringIndex;		/* current position in string scan */
-    int stringLength;		/* length of tag expression string */
-
-    char *rewritebuffer;	/* tag string (after removing escapes) */
-    unsigned int rewritebufferAllocated;	/* available space for rewrites */
-
-    TagSearchExpr *expr;	/* compiled tag expression */
+    int type;			/* Search type (see #defs below) */
+    int id;			/* Item id for searches by id */
+    char *string;		/* Tag expression string */
+    int stringIndex;		/* Current position in string scan */
+    int stringLength;		/* Length of tag expression string */
+    char *rewritebuffer;	/* Tag string (after removing escapes) */
+    unsigned int rewritebufferAllocated;
+				/* Available space for rewrites. */
+    TagSearchExpr *expr;	/* Compiled tag expression. */
 } TagSearch;
 
 /*
@@ -216,8 +210,8 @@ static Tk_ConfigSpec configSpecs[] = {
 };
 
 /*
- * List of all the item types known at present. This is *global* and
- * is protected by typeListMutex.
+ * List of all the item types known at present. This is *global* and is
+ * protected by typeListMutex.
  */
 
 static Tk_ItemType *typeList = NULL;	/* NULL means initialization hasn't
@@ -226,9 +220,10 @@ TCL_DECLARE_MUTEX(typeListMutex)
 
 #ifndef USE_OLD_TAG_SEARCH
 /*
- * Uids for operands in compiled advanced tag search expressions
+ * Uids for operands in compiled advanced tag search expressions.
  * Initialization is done by GetStaticUids()
  */
+
 typedef struct {
     Tk_Uid allUid;
     Tk_Uid currentUid;
@@ -255,95 +250,85 @@ extern Tk_ItemType tkOvalType, tkPolygonType;
 extern Tk_ItemType tkRectangleType, tkTextType, tkWindowType;
 
 /*
- * Prototypes for procedures defined later in this file:
+ * Prototypes for functions defined later in this file:
  */
 
-static void		CanvasBindProc _ANSI_ARGS_((ClientData clientData,
-			    XEvent *eventPtr));
-static void		CanvasBlinkProc _ANSI_ARGS_((ClientData clientData));
-static void		CanvasCmdDeletedProc _ANSI_ARGS_((
-			    ClientData clientData));
-static void		CanvasDoEvent _ANSI_ARGS_((TkCanvas *canvasPtr,
-			    XEvent *eventPtr));
-static void		CanvasEventProc _ANSI_ARGS_((ClientData clientData,
-			    XEvent *eventPtr));
-static int		CanvasFetchSelection _ANSI_ARGS_((
-			    ClientData clientData, int offset,
-			    char *buffer, int maxBytes));
-static Tk_Item *	CanvasFindClosest _ANSI_ARGS_((TkCanvas *canvasPtr,
-			    double coords[2]));
-static void		CanvasFocusProc _ANSI_ARGS_((TkCanvas *canvasPtr,
-			    int gotFocus));
-static void		CanvasLostSelection _ANSI_ARGS_((
-			    ClientData clientData));
-static void		CanvasSelectTo _ANSI_ARGS_((TkCanvas *canvasPtr,
-			    Tk_Item *itemPtr, int index));
-static void		CanvasSetOrigin _ANSI_ARGS_((TkCanvas *canvasPtr,
-			    int xOrigin, int yOrigin));
-static void		CanvasUpdateScrollbars _ANSI_ARGS_((
-			    TkCanvas *canvasPtr));
-static int		CanvasWidgetCmd _ANSI_ARGS_((ClientData clientData,
-			    Tcl_Interp *interp, int argc, Tcl_Obj *CONST *argv));
-static void		CanvasWorldChanged _ANSI_ARGS_((
-			    ClientData instanceData));
-static int		ConfigureCanvas _ANSI_ARGS_((Tcl_Interp *interp,
-			    TkCanvas *canvasPtr, int argc, Tcl_Obj *CONST *argv,
-			    int flags));
-static void		DestroyCanvas _ANSI_ARGS_((char *memPtr));
-static void		DisplayCanvas _ANSI_ARGS_((ClientData clientData));
-static void		DoItem _ANSI_ARGS_((Tcl_Interp *interp,
-			    Tk_Item *itemPtr, Tk_Uid tag));
-static void		EventuallyRedrawItem _ANSI_ARGS_((Tk_Canvas canvas,
-			    Tk_Item *itemPtr));
+static void		CanvasBindProc(ClientData clientData,
+			    XEvent *eventPtr);
+static void		CanvasBlinkProc(ClientData clientData);
+static void		CanvasCmdDeletedProc(ClientData clientData);
+static void		CanvasDoEvent(TkCanvas *canvasPtr, XEvent *eventPtr);
+static void		CanvasEventProc(ClientData clientData,
+			    XEvent *eventPtr);
+static int		CanvasFetchSelection(ClientData clientData, int offset,
+			    char *buffer, int maxBytes);
+static Tk_Item *	CanvasFindClosest(TkCanvas *canvasPtr,
+			    double coords[2]);
+static void		CanvasFocusProc(TkCanvas *canvasPtr, int gotFocus);
+static void		CanvasLostSelection(ClientData clientData);
+static void		CanvasSelectTo(TkCanvas *canvasPtr,
+			    Tk_Item *itemPtr, int index);
+static void		CanvasSetOrigin(TkCanvas *canvasPtr,
+			    int xOrigin, int yOrigin);
+static void		CanvasUpdateScrollbars(TkCanvas *canvasPtr);
+static int		CanvasWidgetCmd(ClientData clientData,
+			    Tcl_Interp *interp, int argc,
+			    Tcl_Obj *CONST *argv);
+static void		CanvasWorldChanged(
+			    ClientData instanceData);
+static int		ConfigureCanvas(Tcl_Interp *interp,
+			    TkCanvas *canvasPtr, int argc,
+			    Tcl_Obj *CONST *argv, int flags);
+static void		DestroyCanvas(char *memPtr);
+static void		DisplayCanvas(ClientData clientData);
+static void		DoItem(Tcl_Interp *interp,
+			    Tk_Item *itemPtr, Tk_Uid tag);
+static void		EventuallyRedrawItem(Tk_Canvas canvas,
+			    Tk_Item *itemPtr);
 #ifdef USE_OLD_TAG_SEARCH
-static int		FindItems _ANSI_ARGS_((Tcl_Interp *interp,
-			    TkCanvas *canvasPtr, int argc, Tcl_Obj *CONST *argv,
-			    Tcl_Obj *newTagObj, int first));
+static int		FindItems(Tcl_Interp *interp, TkCanvas *canvasPtr,
+			    int argc, Tcl_Obj *CONST *argv,
+			    Tcl_Obj *newTagObj, int first);
 #else /* USE_OLD_TAG_SEARCH */
-static int		FindItems _ANSI_ARGS_((Tcl_Interp *interp,
-			    TkCanvas *canvasPtr, int argc, Tcl_Obj *CONST *argv,
+static int		FindItems(Tcl_Interp *interp, TkCanvas *canvasPtr,
+			    int argc, Tcl_Obj *CONST *argv,
 			    Tcl_Obj *newTagObj, int first,
-			    TagSearch **searchPtrPtr));
+			    TagSearch **searchPtrPtr);
 #endif /* USE_OLD_TAG_SEARCH */
-static int		FindArea _ANSI_ARGS_((Tcl_Interp *interp,
-			    TkCanvas *canvasPtr, Tcl_Obj *CONST *argv, Tk_Uid uid,
-			    int enclosed));
-static double		GridAlign _ANSI_ARGS_((double coord, double spacing));
-static CONST char**	TkGetStringsFromObjs _ANSI_ARGS_((int argc,
-			    Tcl_Obj *CONST *objv));
-static void		InitCanvas _ANSI_ARGS_((void));
+static int		FindArea(Tcl_Interp *interp, TkCanvas *canvasPtr,
+			    Tcl_Obj *CONST *argv, Tk_Uid uid, int enclosed);
+static double		GridAlign(double coord, double spacing);
+static CONST char**	TkGetStringsFromObjs(int argc, Tcl_Obj *CONST *objv);
+static void		InitCanvas(void);
 #ifdef USE_OLD_TAG_SEARCH
-static Tk_Item *	NextItem _ANSI_ARGS_((TagSearch *searchPtr));
+static Tk_Item *	NextItem(TagSearch *searchPtr);
 #endif /* USE_OLD_TAG_SEARCH */
-static void		PickCurrentItem _ANSI_ARGS_((TkCanvas *canvasPtr,
-			    XEvent *eventPtr));
-static Tcl_Obj *	ScrollFractions _ANSI_ARGS_((int screen1,
-			    int screen2, int object1, int object2));
+static void		PickCurrentItem(TkCanvas *canvasPtr, XEvent *eventPtr);
+static Tcl_Obj *	ScrollFractions(int screen1,
+			    int screen2, int object1, int object2);
 #ifdef USE_OLD_TAG_SEARCH
-static void		RelinkItems _ANSI_ARGS_((TkCanvas *canvasPtr,
-			    Tcl_Obj *tag, Tk_Item *prevPtr));
-static Tk_Item *	StartTagSearch _ANSI_ARGS_((TkCanvas *canvasPtr,
-			    Tcl_Obj *tag, TagSearch *searchPtr));
+static void		RelinkItems(TkCanvas *canvasPtr,
+			    Tcl_Obj *tag, Tk_Item *prevPtr);
+static Tk_Item *	StartTagSearch(TkCanvas *canvasPtr,
+			    Tcl_Obj *tag, TagSearch *searchPtr);
 #else /* USE_OLD_TAG_SEARCH */
-static int		RelinkItems _ANSI_ARGS_((TkCanvas *canvasPtr,
-			    Tcl_Obj *tag, Tk_Item *prevPtr,
-			    TagSearch **searchPtrPtr));
-static void 		TagSearchExprInit _ANSI_ARGS_ ((
-			    TagSearchExpr **exprPtrPtr));
-static void		TagSearchExprDestroy _ANSI_ARGS_((TagSearchExpr *expr));
-static void		TagSearchDestroy _ANSI_ARGS_((TagSearch *searchPtr));
-static int		TagSearchScan _ANSI_ARGS_((TkCanvas *canvasPtr,
-			    Tcl_Obj *tag, TagSearch **searchPtrPtr));
-static int		TagSearchScanExpr _ANSI_ARGS_((Tcl_Interp *interp,
-			    TagSearch *searchPtr, TagSearchExpr *expr));
-static int		TagSearchEvalExpr _ANSI_ARGS_((TagSearchExpr *expr,
-			    Tk_Item *itemPtr));
-static Tk_Item *	TagSearchFirst _ANSI_ARGS_((TagSearch *searchPtr));
-static Tk_Item *	TagSearchNext _ANSI_ARGS_((TagSearch *searchPtr));
+static int		RelinkItems(TkCanvas *canvasPtr, Tcl_Obj *tag,
+			    Tk_Item *prevPtr, TagSearch **searchPtrPtr);
+static void 		TagSearchExprInit(TagSearchExpr **exprPtrPtr);
+static void		TagSearchExprDestroy(TagSearchExpr *expr);
+static void		TagSearchDestroy(TagSearch *searchPtr);
+static int		TagSearchScan(TkCanvas *canvasPtr,
+			    Tcl_Obj *tag, TagSearch **searchPtrPtr);
+static int		TagSearchScanExpr(Tcl_Interp *interp,
+			    TagSearch *searchPtr, TagSearchExpr *expr);
+static int		TagSearchEvalExpr(TagSearchExpr *expr,
+			    Tk_Item *itemPtr);
+static Tk_Item *	TagSearchFirst(TagSearch *searchPtr);
+static Tk_Item *	TagSearchNext(TagSearch *searchPtr);
 #endif /* USE_OLD_TAG_SEARCH */
 
 /*
- * The structure below defines canvas class behavior by means of procedures
+ * The structure below defines canvas class behavior by means of functions
  * that can be invoked from generic window code.
  */
 
@@ -382,9 +367,8 @@ static Tk_ClassProcs canvasClass = {
  *
  * Tk_CanvasObjCmd --
  *
- *	This procedure is invoked to process the "canvas" Tcl
- *	command.  See the user documentation for details on what
- *	it does.
+ *	This function is invoked to process the "canvas" Tcl command. See the
+ *	user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -397,8 +381,7 @@ static Tk_ClassProcs canvasClass = {
 
 int
 Tk_CanvasObjCmd(clientData, interp, argc, argv)
-    ClientData clientData;		/* Main window associated with
-				 * interpreter. */
+    ClientData clientData;	/* Main window associated with interpreter. */
     Tcl_Interp *interp;		/* Current interpreter. */
     int argc;			/* Number of arguments. */
     Tcl_Obj *CONST argv[];	/* Argument objects. */
@@ -423,9 +406,9 @@ Tk_CanvasObjCmd(clientData, interp, argc, argv)
     }
 
     /*
-     * Initialize fields that won't be initialized by ConfigureCanvas,
-     * or which ConfigureCanvas expects to have reasonable values
-     * (e.g. resource pointers).
+     * Initialize fields that won't be initialized by ConfigureCanvas, or
+     * which ConfigureCanvas expects to have reasonable values (e.g. resource
+     * pointers).
      */
 
     canvasPtr = (TkCanvas *) ckalloc(sizeof(TkCanvas));
@@ -534,9 +517,9 @@ Tk_CanvasObjCmd(clientData, interp, argc, argv)
  *
  * CanvasWidgetCmd --
  *
- *	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.
@@ -549,21 +532,20 @@ 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. */
+    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;
-    Tk_Item *itemPtr = NULL;		/* Initialization needed only to
-					 * prevent compiler warning. */
+    Tk_Item *itemPtr = NULL;	/* Initialization needed only to prevent
+				 * compiler warning. */
 #ifdef USE_OLD_TAG_SEARCH
     TagSearch search;
 #else /* USE_OLD_TAG_SEARCH */
-    TagSearch *searchPtr = NULL;	/* Allocated by first TagSearchScan
-					 * Freed by TagSearchDestroy */
+    TagSearch *searchPtr = NULL;/* Allocated by first TagSearchScan, freed by
+				 * TagSearchDestroy */
 #endif /* USE_OLD_TAG_SEARCH */
 
     int index;
@@ -616,9 +598,9 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 
     case CANV_BBOX: {
 	int i, gotAny;
-	int x1 = 0, y1 = 0, x2 = 0, y2 = 0;	/* Initializations needed
-						 * only to prevent compiler
-						 * warnings. */
+	int x1 = 0, y1 = 0, x2 = 0, y2 = 0;	/* Initializations needed only
+						 * to prevent overcautious
+						 * compiler warnings. */
 
 	if (objc < 3) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "tagOrId ?tagOrId ...?");
@@ -656,7 +638,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	}
 	if (gotAny) {
 	    char buf[TCL_INTEGER_SPACE * 4];
-	    
+
 	    sprintf(buf, "%d %d %d %d", x1, y1, x2, y2);
 	    Tcl_SetResult(interp, buf, TCL_VOLATILE);
 	}
@@ -672,8 +654,8 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	}
 
 	/*
-	 * Figure out what object to use for the binding (individual
-	 * item vs. tag).
+	 * Figure out what object to use for the binding (individual item vs.
+	 * tag).
 	 */
 
 	object = 0;
@@ -729,8 +711,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 #endif /* USE_OLD_TAG_SEARCH */
 
 	/*
-	 * Make a binding table if the canvas doesn't already have
-	 * one.
+	 * Make a binding table if the canvas doesn't already have one.
 	 */
 
 	if (canvasPtr->bindingTable == NULL) {
@@ -750,8 +731,9 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 #ifndef USE_OLD_TAG_SEARCH
 	    if (searchPtr->type == SEARCH_TYPE_EXPR) {
 		/*
-		 * if new tag expression, then insert in linked list
+		 * If new tag expression, then insert in linked list.
 		 */
+
 	    	TagSearchExpr *expr, **lastPtr;
 
 		lastPtr = &(canvasPtr->bindTagExprs);
@@ -763,15 +745,17 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 		}
 		if (!expr) {
 		    /*
-		     * transfer ownership of expr to bindTagExprs list
+		     * Transfer ownership of expr to bindTagExprs list.
 		     */
+
 		    *lastPtr = searchPtr->expr;
 		    searchPtr->expr->next = NULL;
 
 		    /*
-		     * flag in TagSearch that expr has changed ownership
-		     * so that TagSearchDestroy doesn't try to free it
+		     * Flag in TagSearch that expr has changed ownership so
+		     * that TagSearchDestroy doesn't try to free it.
 		     */
+
 		    searchPtr->expr = NULL;
 		}
 	    }
@@ -802,17 +786,18 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	    }
 	} else if (objc == 4) {
 	    CONST char *command;
-    
+
 	    command = Tk_GetBinding(interp, canvasPtr->bindingTable,
 		    object, Tcl_GetString(objv[3]));
 	    if (command == NULL) {
 		CONST char *string;
 
-		string = Tcl_GetStringResult(interp); 
+		string = Tcl_GetStringResult(interp);
+
 		/*
-		 * Ignore missing binding errors.  This is a special hack
-		 * that relies on the error message returned by FindSequence
-		 * in tkBind.c.
+		 * Ignore missing binding errors. This is a special hack that
+		 * relies on the error message returned by FindSequence in
+		 * tkBind.c.
 		 */
 
 		if (string[0] != '\0') {
@@ -1076,10 +1061,10 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	    }
 
 	    /*
-	     * Redraw both item's old and new areas:  it's possible
-	     * that a delete could result in a new area larger than
-	     * the old area. Except if the insertProc sets the
-	     * TK_ITEM_DONT_REDRAW flag, nothing more needs to be done.
+	     * Redraw both item's old and new areas: it's possible that a
+	     * delete could result in a new area larger than the old area.
+	     * Except if the insertProc sets the TK_ITEM_DONT_REDRAW flag,
+	     * nothing more needs to be done.
 	     */
 
 	    x1 = itemPtr->x1; y1 = itemPtr->y1;
@@ -1200,7 +1185,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	if (objc == 2) {
 	    if (itemPtr != NULL) {
 		char buf[TCL_INTEGER_SPACE];
-		
+
 		sprintf(buf, "%d", itemPtr->id);
 		Tcl_SetResult(interp, buf, TCL_VOLATILE);
 	    }
@@ -1336,11 +1321,10 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	    }
 
 	    /*
-	     * Redraw both item's old and new areas:  it's possible
-	     * that an insertion could result in a new area either
-	     * larger or smaller than the old area. Except if the
-	     * insertProc sets the TK_ITEM_DONT_REDRAW flag, nothing
-	     * more needs to be done.
+	     * Redraw both item's old and new areas: it's possible that an
+	     * insertion could result in a new area either larger or smaller
+	     * than the old area. Except if the insertProc sets the
+	     * TK_ITEM_DONT_REDRAW flag, nothing more needs to be done.
 	     */
 
 	    x1 = itemPtr->x1; y1 = itemPtr->y1;
@@ -1423,8 +1407,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	}
 
 	/*
-	 * First find the item just after which we'll insert the
-	 * named items.
+	 * First find the item just after which we'll insert the named items.
 	 */
 
 	if (objc == 3) {
@@ -1487,8 +1470,7 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	}
 
 	/*
-	 * First find the item just after which we'll insert the
-	 * named items.
+	 * First find the item just after which we'll insert the named items.
 	 */
 
 	if (objc == 3) {
@@ -1803,7 +1785,8 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
 	break;
     }
     }
-    done:
+
+  done:
 #ifndef USE_OLD_TAG_SEARCH
     TagSearchDestroy(searchPtr);
 #endif /* not USE_OLD_TAG_SEARCH */
@@ -1816,9 +1799,9 @@ CanvasWidgetCmd(clientData, interp, objc, objv)
  *
  * DestroyCanvas --
  *
- *	This procedure is invoked by Tcl_EventuallyFree or Tcl_Release
- *	to clean up the internal structure of a canvas at a safe time
- *	(when no-one is using it anymore).
+ *	This function is invoked by Tcl_EventuallyFree or Tcl_Release to clean
+ *	up the internal structure of a canvas at a safe time (when no-one is
+ *	using it anymore).
  *
  * Results:
  *	None.
@@ -1855,9 +1838,8 @@ DestroyCanvas(memPtr)
     }
 
     /*
-     * 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_DeleteHashTable(&canvasPtr->idTable);
@@ -1886,18 +1868,17 @@ DestroyCanvas(memPtr)
  *
  * ConfigureCanvas --
  *
- *	This procedure is called to process an objv/objc list, plus
- *	the Tk option database, in order to configure (or
- *	reconfigure) a canvas widget.
+ *	This function is called to process an objv/objc list, plus the Tk
+ *	option database, in order to configure (or reconfigure) a canvas
+ *	widget.
  *
  * Results:
- *	The return value is a standard Tcl result.  If TCL_ERROR is
- *	returned, then the interp's result contains an error message.
+ *	The return value is a standard Tcl result. If TCL_ERROR is returned,
+ *	then the interp's result contains an error message.
  *
  * Side effects:
- *	Configuration information, such as colors, border width,
- *	etc. get set for canvasPtr;  old resources get freed,
- *	if there were any.
+ *	Configuration information, such as colors, border width, etc. get set
+ *	for canvasPtr; old resources get freed, if there were any.
  *
  *----------------------------------------------------------------------
  */
@@ -1905,8 +1886,8 @@ 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 already have values for some fields. */
+    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. */
@@ -1921,9 +1902,8 @@ ConfigureCanvas(interp, canvasPtr, objc, objv, flags)
     }
 
     /*
-     * A few options need special processing, such as setting the
-     * background from a 3-D border and creating a GC for copying
-     * bits to the screen.
+     * A few options need special processing, such as setting the background
+     * from a 3-D border and creating a GC for copying bits to the screen.
      */
 
     Tk_SetBackgroundFromBorder(canvasPtr->tkwin, canvasPtr->bgBorder);
@@ -1951,8 +1931,8 @@ ConfigureCanvas(interp, canvasPtr, objc, objv, flags)
 	    canvasPtr->height + 2*canvasPtr->inset);
 
     /*
-     * Restart the cursor timing sequence in case the on-time or off-time
-     * just changed.
+     * Restart the cursor timing sequence in case the on-time or off-time just
+     * changed.
      */
 
     if (canvasPtr->textInfo.gotFocus) {
@@ -2014,8 +1994,8 @@ ConfigureCanvas(interp, canvasPtr, objc, objv, flags)
     }
 
     /*
-     * Reset the canvas's origin (this is a no-op unless confine
-     * mode has just been turned on or the scroll region has changed).
+     * Reset the canvas's origin (this is a no-op unless confine mode has just
+     * been turned on or the scroll region has changed).
      */
 
     CanvasSetOrigin(canvasPtr, canvasPtr->xOrigin, canvasPtr->yOrigin);
@@ -2032,21 +2012,21 @@ ConfigureCanvas(interp, canvasPtr, objc, objv, flags)
  *
  * CanvasWorldChanged --
  *
- *	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.
  *
  * Side effects:
- *	Configures all items in the canvas with a empty argc/argv, for
- *	the side effect of causing all the items to recompute their
- *	geometry and to be redisplayed.
+ *	Configures all items in the canvas with a empty argc/argv, for the
+ *	side effect of causing all the items to recompute their geometry and
+ *	to be redisplayed.
  *
  *---------------------------------------------------------------------------
  */
- 
+
 static void
 CanvasWorldChanged(instanceData)
     ClientData instanceData;	/* Information about widget. */
@@ -2077,9 +2057,9 @@ CanvasWorldChanged(instanceData)
  *
  * DisplayCanvas --
  *
- *	This procedure redraws the contents of a canvas window.
- *	It is invoked as a do-when-idle handler, so it only runs
- *	when there's nothing else for the application to do.
+ *	This function redraws the contents of a canvas window. It is invoked
+ *	as a do-when-idle handler, so it only runs when there's nothing else
+ *	for the application to do.
  *
  * Results:
  *	None.
@@ -2109,8 +2089,8 @@ DisplayCanvas(clientData)
     }
 
     /*
-     * Choose a new current item if that is needed (this could cause
-     * event handlers to be invoked).
+     * Choose a new current item if that is needed (this could cause event
+     * handlers to be invoked).
      */
 
     while (canvasPtr->flags & REPICK_NEEDED) {
@@ -2125,9 +2105,9 @@ DisplayCanvas(clientData)
     }
 
     /*
-     * Scan through the item list, registering the bounding box
-     * for all items that didn't do that for the final coordinates
-     * yet. This can be determined by the FORCE_REDRAW flag.
+     * Scan through the item list, registering the bounding box for all items
+     * that didn't do that for the final coordinates yet. This can be
+     * determined by the FORCE_REDRAW flag.
      */
 
     for (itemPtr = canvasPtr->firstItemPtr; itemPtr != NULL;
@@ -2139,8 +2119,8 @@ DisplayCanvas(clientData)
 	}
     }
     /*
-     * Compute the intersection between the area that needs redrawing
-     * and the area that's visible on the screen.
+     * Compute the intersection between the area that needs redrawing and the
+     * area that's visible on the screen.
      */
 
     if ((canvasPtr->redrawX1 < canvasPtr->redrawX2)
@@ -2164,66 +2144,62 @@ DisplayCanvas(clientData)
 	if ((screenX1 >= screenX2) || (screenY1 >= screenY2)) {
 	    goto borders;
 	}
-    
+
 	/*
-	 * Redrawing is done in a temporary pixmap that is allocated
-	 * here and freed at the end of the procedure.  All drawing
-	 * is done to the pixmap, and the pixmap is copied to the
-	 * screen at the end of the procedure. The temporary pixmap
-	 * serves two purposes:
+	 * Redrawing is done in a temporary pixmap that is allocated here and
+	 * freed at the end of the function. All drawing is done to the
+	 * pixmap, and the pixmap is copied to the screen at the end of the
+	 * function. The temporary pixmap serves two purposes:
 	 *
-	 * 1. It provides a smoother visual effect (no clearing and
-	 *    gradual redraw will be visible to users).
-	 * 2. It allows us to redraw only the objects that overlap
-	 *    the redraw area.  Otherwise incorrect results could
-	 *	  occur from redrawing things that stick outside of
-	 *	  the redraw area (we'd have to redraw everything in
-	 *    order to make the overlaps look right).
+	 * 1. It provides a smoother visual effect (no clearing and gradual
+	 *    redraw will be visible to users).
+	 * 2. It allows us to redraw only the objects that overlap the redraw
+	 *    area. Otherwise incorrect results could occur from redrawing
+	 *    things that stick outside of the redraw area (we'd have to
+	 *    redraw everything in order to make the overlaps look right).
 	 *
 	 * Some tricky points about the pixmap:
 	 *
-	 * 1. We only allocate a large enough pixmap to hold the
-	 *    area that has to be redisplayed.  This saves time in
-	 *    in the X server for large objects that cover much
-	 *    more than the area being redisplayed:  only the area
-	 *    of the pixmap will actually have to be redrawn.
-	 * 2. Some X servers (e.g. the one for DECstations) have troubles
-	 *    with characters that overlap an edge of the pixmap (on the
-	 *    DEC servers, as of 8/18/92, such characters are drawn one
-	 *    pixel too far to the right).  To handle this problem,
-	 *    make the pixmap a bit larger than is absolutely needed
-	 *    so that for normal-sized fonts the characters that overlap
-	 *    the edge of the pixmap will be outside the area we care
-	 *    about.
+	 * 1. We only allocate a large enough pixmap to hold the area that has
+	 *    to be redisplayed. This saves time in in the X server for large
+	 *    objects that cover much more than the area being redisplayed:
+	 *    only the area of the pixmap will actually have to be redrawn.
+	 * 2. Some X servers (e.g. the one for DECstations) have troubles with
+	 *    with characters that overlap an edge of the pixmap (on the DEC
+	 *    servers, as of 8/18/92, such characters are drawn one pixel too
+	 *    far to the right). To handle this problem, make the pixmap a bit
+	 *    larger than is absolutely needed so that for normal-sized fonts
+	 *    the characters that overlap the edge of the pixmap will be
+	 *    outside the area we care about.
 	 */
-    
+
 	canvasPtr->drawableXOrigin = screenX1 - 30;
 	canvasPtr->drawableYOrigin = screenY1 - 30;
 	pixmap = Tk_GetPixmap(Tk_Display(tkwin), Tk_WindowId(tkwin),
 	    (screenX2 + 30 - canvasPtr->drawableXOrigin),
 	    (screenY2 + 30 - canvasPtr->drawableYOrigin),
 	    Tk_Depth(tkwin));
-    
+
 	/*
 	 * Clear the area to be redrawn.
 	 */
-    
+
 	width = screenX2 - screenX1;
 	height = screenY2 - screenY1;
-    
+
 	XFillRectangle(Tk_Display(tkwin), pixmap, canvasPtr->pixmapGC,
 		screenX1 - canvasPtr->drawableXOrigin,
 		screenY1 - canvasPtr->drawableYOrigin, (unsigned int) width,
 		(unsigned int) height);
-    
+
 	/*
-	 * Scan through the item list, redrawing those items that need it.
-	 * An item must be redraw if either (a) it intersects the smaller
+	 * Scan through the item list, redrawing those items that need it. An
+	 * item must be redraw if either (a) it intersects the smaller
 	 * on-screen area or (b) it intersects the full canvas area and its
-	 * type requests that it be redrawn always (e.g. so subwindows can
-	 * be unmapped when they move off-screen).
+	 * type requests that it be redrawn always (e.g. so subwindows can be
+	 * unmapped when they move off-screen).
 	 */
-    
+
 	for (itemPtr = canvasPtr->firstItemPtr; itemPtr != NULL;
 		itemPtr = itemPtr->nextPtr) {
 	    if ((itemPtr->x1 >= screenX2)
@@ -2247,12 +2223,12 @@ DisplayCanvas(clientData)
 		    canvasPtr->display, pixmap, screenX1, screenY1, width,
 		    height);
 	}
-    
+
 	/*
-	 * Copy from the temporary pixmap to the screen, then free up
-	 * the temporary pixmap.
+	 * Copy from the temporary pixmap to the screen, then free up the
+	 * temporary pixmap.
 	 */
-    
+
 	XCopyArea(Tk_Display(tkwin), pixmap, Tk_WindowId(tkwin),
 		canvasPtr->pixmapGC,
 		screenX1 - canvasPtr->drawableXOrigin,
@@ -2267,7 +2243,7 @@ DisplayCanvas(clientData)
      * Draw the window borders, if needed.
      */
 
-    borders:
+  borders:
     if (canvasPtr->flags & REDRAW_BORDERS) {
 	canvasPtr->flags &= ~REDRAW_BORDERS;
 	if (canvasPtr->borderWidth > 0) {
@@ -2295,7 +2271,7 @@ DisplayCanvas(clientData)
 	}
     }
 
-    done:
+  done:
     canvasPtr->flags &= ~(REDRAW_PENDING|BBOX_NOT_EMPTY);
     canvasPtr->redrawX1 = canvasPtr->redrawX2 = 0;
     canvasPtr->redrawY1 = canvasPtr->redrawY2 = 0;
@@ -2309,15 +2285,15 @@ DisplayCanvas(clientData)
  *
  * CanvasEventProc --
  *
- *	This procedure is invoked by the Tk dispatcher for various
- *	events on canvases.
+ *	This function is invoked by the Tk dispatcher for various events on
+ *	canvases.
  *
  * 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.
  *
  *--------------------------------------------------------------
  */
@@ -2360,8 +2336,8 @@ CanvasEventProc(clientData, eventPtr)
 	canvasPtr->flags |= UPDATE_SCROLLBARS;
 
 	/*
-	 * The call below is needed in order to recenter the canvas if
-	 * it's confined and its scroll region is smaller than the window.
+	 * The call below is needed in order to recenter the canvas if it's
+	 * confined and its scroll region is smaller than the window.
 	 */
 
 	CanvasSetOrigin(canvasPtr, canvasPtr->xOrigin, canvasPtr->yOrigin);
@@ -2382,9 +2358,9 @@ CanvasEventProc(clientData, eventPtr)
 	Tk_Item *itemPtr;
 
 	/*
-	 * Special hack:  if the canvas is unmapped, then must notify
-	 * all items with "alwaysRedraw" set, so that they know that
-	 * they are no longer displayed.
+	 * Special hack: if the canvas is unmapped, then must notify all items
+	 * with "alwaysRedraw" set, so that they know that they are no longer
+	 * displayed.
 	 */
 
 	for (itemPtr = canvasPtr->firstItemPtr; itemPtr != NULL;
@@ -2402,9 +2378,9 @@ CanvasEventProc(clientData, eventPtr)
  *
  * CanvasCmdDeletedProc --
  *
- *	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.
@@ -2423,10 +2399,10 @@ CanvasCmdDeletedProc(clientData)
     Tk_Window tkwin = canvasPtr->tkwin;
 
     /*
-     * This procedure could be invoked either because the window was
-     * destroyed and the command was then deleted (in which case tkwin
-     * is NULL) or because the command was deleted, and then this procedure
-     * destroys the widget.
+     * This function could be invoked either because the window was destroyed
+     * and the command was then deleted (in which case tkwin is NULL) or
+     * because the command was deleted, and then this function destroys the
+     * widget.
      */
 
     if (tkwin != NULL) {
@@ -2440,8 +2416,8 @@ CanvasCmdDeletedProc(clientData)
  *
  * Tk_CanvasEventuallyRedraw --
  *
- *	Arrange for part or all of a canvas widget to redrawn at
- *	some convenient time in the future.
+ *	Arrange for part or all of a canvas widget to redrawn at some
+ *	convenient time in the future.
  *
  * Results:
  *	None.
@@ -2461,10 +2437,12 @@ Tk_CanvasEventuallyRedraw(canvas, x1, y1, x2, y2)
 				 * Pixels on edge are not redrawn. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) canvas;
+
     /*
      * If tkwin is NULL, the canvas has been destroyed, so we can't really
      * redraw it.
      */
+
     if (canvasPtr->tkwin == NULL) {
 	return;
     }
@@ -2506,8 +2484,8 @@ Tk_CanvasEventuallyRedraw(canvas, x1, y1, x2, y2)
  *
  * EventuallyRedrawItem --
  *
- *	Arrange for part or all of a canvas widget to redrawn at
- *	some convenient time in the future.
+ *	Arrange for part or all of a canvas widget to redrawn at some
+ *	convenient time in the future.
  *
  * Results:
  *	None.
@@ -2521,7 +2499,7 @@ 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. */
+    Tk_Item *itemPtr;		/* Item to be redrawn. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) canvas;
     if ((itemPtr->x1 >= itemPtr->x2) || (itemPtr->y1 >= itemPtr->y2) ||
@@ -2567,27 +2545,26 @@ EventuallyRedrawItem(canvas, itemPtr)
  *
  * Tk_CreateItemType --
  *
- *	This procedure may be invoked to add a new kind of canvas
- *	element to the core item types supported by Tk.
+ *	This function may be invoked to add a new kind of canvas element to
+ *	the core item types supported by Tk.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	From now on, the new item type will be useable in canvas
- *	widgets (e.g. typePtr->name can be used as the item type
- *	in "create" widget commands).  If there was already a
- *	type with the same name as in typePtr, it is replaced with
- *	the new type.
+ *	From now on, the new item type will be useable in canvas widgets
+ *	(e.g. typePtr->name can be used as the item type in "create" widget
+ *	commands). If there was already a type with the same name as in
+ *	typePtr, it is replaced with the new type.
  *
  *--------------------------------------------------------------
  */
 
 void
 Tk_CreateItemType(typePtr)
-    Tk_ItemType *typePtr;		/* Information about item type;
-					 * storage must be statically
-					 * allocated (must live forever). */
+    Tk_ItemType *typePtr;	/* Information about item type; storage must
+				 * be statically allocated (must live
+				 * forever). */
 {
     Tk_ItemType *typePtr2, *prevPtr;
 
@@ -2621,14 +2598,14 @@ Tk_CreateItemType(typePtr)
  *
  * Tk_GetItemTypes --
  *
- *	This procedure returns a pointer to the list of all item
- *	types. Note that this is inherently thread-unsafe, but since
- *	item types are only ever registered very rarely this is
- *	unlikely to be a problem in practice.
+ *	This function returns a pointer to the list of all item types. Note
+ *	that this is inherently thread-unsafe, but since item types are only
+ *	ever registered very rarely this is unlikely to be a problem in
+ *	practice.
  *
  * Results:
- *	The return value is a pointer to the first in the list
- *	of item types currently supported by canvases.
+ *	The return value is a pointer to the first in the list of item types
+ *	currently supported by canvases.
  *
  * Side effects:
  *	None.
@@ -2650,9 +2627,8 @@ Tk_GetItemTypes()
  *
  * InitCanvas --
  *
- *	This procedure is invoked to perform once-only-ever
- *	initialization for the module, such as setting up the type
- *	table.
+ *	This function is invoked to perform once-only-ever initialization for
+ *	the module, such as setting up the type table.
  *
  * Results:
  *	None.
@@ -2690,33 +2666,30 @@ InitCanvas()
  *
  * StartTagSearch --
  *
- *	This procedure is called to initiate an enumeration of
- *	all items in a given canvas that contain a given tag.
+ *	This function is called to initiate an enumeration of all items in a
+ *	given canvas that contain a given tag.
  *
  * Results:
- *	The return value is a pointer to the first item in
- *	canvasPtr that matches tag, or NULL if there is no
- *	such item.  The information at *searchPtr is initialized
- *	such that successive calls to NextItem will return
- *	successive items that match tag.
+ *	The return value is a pointer to the first item in canvasPtr that
+ *	matches tag, or NULL if there is no such item. The information at
+ *	*searchPtr is initialized such that successive calls to NextItem will
+ *	return successive items that match tag.
  *
  * Side effects:
- *	SearchPtr is linked into a list of searches in progress
- *	on canvasPtr, so that elements can safely be deleted
- *	while the search is in progress.  EndTagSearch must be
- *	called at the end of the search to unlink searchPtr from
- *	this list.
+ *	SearchPtr is linked into a list of searches in progress on canvasPtr,
+ *	so that elements can safely be deleted while the search is in
+ *	progress. EndTagSearch must be called at the end of the search to
+ *	unlink searchPtr from this list.
  *
  *--------------------------------------------------------------
  */
 
 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 initialized here. */
+    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;
     Tk_Item *itemPtr, *lastPtr;
@@ -2738,10 +2711,10 @@ StartTagSearch(canvasPtr, tagObj, searchPtr)
     searchPtr->searchOver = 0;
 
     /*
-     * Find the first matching item in one of several ways. If the tag
-     * is a number then it selects the single item with the matching
-     * identifier.  In this case see if the item being requested is the
-     * hot item, in which case the search can be skipped.
+     * Find the first matching item in one of several ways. If the tag is a
+     * number then it selects the single item with the matching identifier.
+     * In this case see if the item being requested is the hot item, in which
+     * case the search can be skipped.
      */
 
     if (isdigit(UCHAR(*tag))) {
@@ -2785,7 +2758,7 @@ StartTagSearch(canvasPtr, tagObj, searchPtr)
     }
 
     /*
-     * None of the above.  Search for an item with a matching tag.
+     * None of the above. Search for an item with a matching tag.
      */
 
     for (lastPtr = NULL, itemPtr = canvasPtr->firstItemPtr; itemPtr != NULL;
@@ -2809,15 +2782,15 @@ StartTagSearch(canvasPtr, tagObj, searchPtr)
  *
  * NextItem --
  *
- *	This procedure returns successive items that match a given
- *	tag;  it should be called only after StartTagSearch has been
- *	used to begin a search.
+ *	This function returns successive items that match a given tag; it
+ *	should be called only after StartTagSearch has been used to begin a
+ *	search.
  *
  * Results:
- *	The return value is a pointer to the next item that matches
- *	the tag specified to StartTagSearch, or NULL if no such
- *	item exists.  *SearchPtr is updated so that the next call
- *	to this procedure will return the next item.
+ *	The return value is a pointer to the next item that matches the tag
+ *	specified to StartTagSearch, or NULL if no such item exists.
+ *	*SearchPtr is updated so that the next call to this function will
+ *	return the next item.
  *
  * Side effects:
  *	None.
@@ -2827,8 +2800,7 @@ StartTagSearch(canvasPtr, tagObj, searchPtr)
 
 static Tk_Item *
 NextItem(searchPtr)
-    TagSearch *searchPtr;		/* Record describing search in
-					 * progress. */
+    TagSearch *searchPtr;	/* Record describing search in progress. */
 {
     Tk_Item *itemPtr, *lastPtr;
     int count;
@@ -2836,8 +2808,8 @@ NextItem(searchPtr)
     Tk_Uid *tagPtr;
 
     /*
-     * Find next item in list (this may not actually be a suitable
-     * one to return), and return if there are no items left.
+     * Find next item in list (this may not actually be a suitable one to
+     * return), and return if there are no items left.
      */
 
     lastPtr = searchPtr->lastPtr;
@@ -2852,10 +2824,10 @@ NextItem(searchPtr)
     }
     if (itemPtr != searchPtr->currentPtr) {
 	/*
-	 * The structure of the list has changed.  Probably the
-	 * previously-returned item was removed from the list.
-	 * In this case, don't advance lastPtr;  just return
-	 * its new successor (i.e. do nothing here).
+	 * The structure of the list has changed. Probably the previously-
+	 * returned item was removed from the list. In this case, don't
+	 * advance lastPtr; just return its new successor (i.e. do nothing
+	 * here).
 	 */
     } else {
 	lastPtr = itemPtr;
@@ -2898,11 +2870,10 @@ NextItem(searchPtr)
  *
  * GetStaticUids --
  *
- *	This procedure is invoked to return a structure filled with
- *	the Uids used when doing tag searching. If it was never before
- *	called in the current thread, it initializes the structure for
- *	that thread (uids are only ever local to one thread [Bug
- *	1114977]).
+ *	This function is invoked to return a structure filled with the Uids
+ *	used when doing tag searching. If it was never before called in the
+ *	current thread, it initializes the structure for that thread (uids are
+ *	only ever local to one thread [Bug 1114977]).
  *
  * Results:
  *	None.
@@ -2939,7 +2910,7 @@ GetStaticUids()
  *
  * TagSearchExprInit --
  *
- *	This procedure allocates and initializes one TagSearchExpr struct.
+ *	This function allocates and initializes one TagSearchExpr struct.
  *
  * Results:
  *
@@ -2971,7 +2942,7 @@ TagSearchExpr **exprPtrPtr;
  *
  * TagSearchExprDestroy --
  *
- *	This procedure destroys one TagSearchExpr structure.
+ *	This function destroys one TagSearchExpr structure.
  *
  * Results:
  *
@@ -2997,32 +2968,29 @@ TagSearchExprDestroy(expr)
  *
  * TagSearchScan --
  *
- *	This procedure is called to initiate an enumeration of all
- *	items in a given canvas that contain a tag that matches the
- *	tagOrId expression.
+ *	This function is called to initiate an enumeration of all items in a
+ *	given canvas that contain a tag that matches the tagOrId expression.
  *
  * Results:
- *	The return value indicates if the tagOrId expression was
- *	successfully scanned (syntax).  The information at *searchPtr
- *	is initialized such that a call to TagSearchFirst, followed by
- *	successive calls to TagSearchNext will return items that match
- *	tag.
+ *	The return value indicates if the tagOrId expression was successfully
+ *	scanned (syntax). The information at *searchPtr is initialized such
+ *	that a call to TagSearchFirst, followed by successive calls to
+ *	TagSearchNext will return items that match tag.
  *
  * Side effects:
- *	SearchPtr is linked into a list of searches in progress on
- *	canvasPtr, so that elements can safely be deleted while the
- *	search is in progress.
+ *	SearchPtr is linked into a list of searches in progress on canvasPtr,
+ *	so that elements can safely be deleted while the search is in
+ *	progress.
  *
  *--------------------------------------------------------------
  */
 
 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 initialized here. */
+    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);
     int i;
@@ -3035,20 +3003,32 @@ TagSearchScan(canvasPtr, tagObj, searchPtrPtr)
     if (*searchPtrPtr) {
 	searchPtr = *searchPtrPtr;
     } else {
-	/* Allocate primary search struct on first call */
+	/*
+	 * Allocate primary search struct on first call.
+	 */
+
 	*searchPtrPtr = searchPtr = (TagSearch *) ckalloc(sizeof(TagSearch));
 	searchPtr->expr = NULL;
 
-	/* Allocate buffer for rewritten tags (after de-escaping) */
+	/*
+	 * Allocate buffer for rewritten tags (after de-escaping).
+	 */
+
 	searchPtr->rewritebufferAllocated = 100;
 	searchPtr->rewritebuffer = ckalloc(searchPtr->rewritebufferAllocated);
     }
     TagSearchExprInit(&(searchPtr->expr));
 
-    /* How long is the tagOrId ? */
+    /*
+     * How long is the tagOrId?
+     */
+
     searchPtr->stringLength = strlen(tag);
 
-    /* Make sure there is enough buffer to hold rewritten tags */
+    /*
+     * Make sure there is enough buffer to hold rewritten tags.
+     */
+
     if ((unsigned int)searchPtr->stringLength >=
 	    searchPtr->rewritebufferAllocated) {
 	searchPtr->rewritebufferAllocated = searchPtr->stringLength + 100;
@@ -3057,16 +3037,19 @@ TagSearchScan(canvasPtr, tagObj, searchPtrPtr)
 		searchPtr->rewritebufferAllocated);
     }
 
-    /* Initialize search */
+    /*
+     * Initialize search.
+     */
+
     searchPtr->canvasPtr = canvasPtr;
     searchPtr->searchOver = 0;
     searchPtr->type = SEARCH_TYPE_EMPTY;
 
     /*
-     * Find the first matching item in one of several ways. If the tag
-     * is a number then it selects the single item with the matching
-     * identifier.  In this case see if the item being requested is the
-     * hot item, in which case the search can be skipped.
+     * Find the first matching item in one of several ways. If the tag is a
+     * number then it selects the single item with the matching identifier.
+     * In this case see if the item being requested is the hot item, in which
+     * case the search can be skipped.
      */
 
     if (searchPtr->stringLength && isdigit(UCHAR(*tag))) {
@@ -3080,13 +3063,16 @@ TagSearchScan(canvasPtr, tagObj, searchPtrPtr)
     }
 
     /*
-     * For all other tags and tag expressions convert to a UID.
-     * This UID is kept forever, but this should be thought of
-     * as a cache rather than as a memory leak.
+     * For all other tags and tag expressions convert to a UID. This UID is
+     * kept forever, but this should be thought of as a cache rather than as a
+     * memory leak.
      */
     searchPtr->expr->uid = Tk_GetUid(tag);
 
-    /* short circuit impossible searches for null tags */
+    /*
+     * Short circuit impossible searches for null tags.
+     */
+
     if (searchPtr->stringLength == 0) {
 	return TCL_OK;
     }
@@ -3095,6 +3081,7 @@ TagSearchScan(canvasPtr, tagObj, searchPtrPtr)
      * Pre-scan tag for at least one unquoted "&&" "||" "^" "!"
      *   if not found then use string as simple tag
      */
+
     for (i = 0; i < searchPtr->stringLength ; i++) {
 	if (tag[i] == '"') {
 	    i++;
@@ -3107,14 +3094,12 @@ TagSearchScan(canvasPtr, tagObj, searchPtrPtr)
 		    break;
 		}
 	    }
-	} else {
-	    if ((tag[i] == '&' && tag[i+1] == '&')
-		    || (tag[i] == '|' && tag[i+1] == '|')
-		    || (tag[i] == '^')
-		    || (tag[i] == '!')) {
-		searchPtr->type = SEARCH_TYPE_EXPR;
-		break;
-	    }
+	} else if ((tag[i] == '&' && tag[i+1] == '&')
+		|| (tag[i] == '|' && tag[i+1] == '|')
+		|| (tag[i] == '^')
+		|| (tag[i] == '!')) {
+	    searchPtr->type = SEARCH_TYPE_EXPR;
+	    break;
 	}
     }
 
@@ -3122,13 +3107,17 @@ TagSearchScan(canvasPtr, tagObj, searchPtrPtr)
     searchPtr->stringIndex = 0;
     if (searchPtr->type == SEARCH_TYPE_EXPR) {
 	/*
-	 * an operator was found in the prescan, so
-	 * now compile the tag expression into array of Tk_Uid
-	 * flagging any syntax errors found
+	 * An operator was found in the prescan, so now compile the tag
+	 * expression into array of Tk_Uid flagging any syntax errors found.
 	 */
-	if (TagSearchScanExpr(canvasPtr->interp, searchPtr, searchPtr->expr) != TCL_OK) {
-	    /* Syntax error in tag expression */
-	    /* Result message set by TagSearchScanExpr */
+
+	if (TagSearchScanExpr(canvasPtr->interp, searchPtr,
+		searchPtr->expr) != TCL_OK) {
+	    /*
+	     * Syntax error in tag expression. The result message was set by
+	     * TagSearchScanExpr.
+	     */
+
 	    return TCL_ERROR;
 	}
 	searchPtr->expr->length = searchPtr->expr->index;
@@ -3136,11 +3125,13 @@ TagSearchScan(canvasPtr, tagObj, searchPtrPtr)
 	/*
 	 * All items match.
 	 */
+
 	searchPtr->type = SEARCH_TYPE_ALL;
     } else {
 	/*
 	 * Optimized single-tag search
 	 */
+
 	searchPtr->type = SEARCH_TYPE_TAG;
     }
     return TCL_OK;
@@ -3151,8 +3142,8 @@ TagSearchScan(canvasPtr, tagObj, searchPtrPtr)
  *
  * TagSearchDestroy --
  *
- *	This procedure destroys any dynamic structures that may have
- *	been allocated by TagSearchScan.
+ *	This function destroys any dynamic structures that may have been
+ *	allocated by TagSearchScan.
  *
  * Results:
  *	None
@@ -3165,7 +3156,7 @@ TagSearchScan(canvasPtr, tagObj, searchPtrPtr)
 
 static void
 TagSearchDestroy(searchPtr)
-    TagSearch *searchPtr;		/* Record describing tag search */
+    TagSearch *searchPtr;	/* Record describing tag search */
 {
     if (searchPtr) {
 	TagSearchExprDestroy(searchPtr->expr);
@@ -3179,15 +3170,14 @@ TagSearchDestroy(searchPtr)
  *
  * TagSearchScanExpr --
  *
- *	This recursive procedure is called to scan a tag expression
- *	and compile it into an array of Tk_Uids.
+ *	This recursive function is called to scan a tag expression and compile
+ *	it into an array of Tk_Uids.
  *
  * Results:
- *	The return value indicates if the tagOrId expression was
- *	successfully scanned (syntax).  The information at *searchPtr
- *	is initialized such that a call to TagSearchFirst, followed by
- *	successive calls to TagSearchNext will return items that match
- *	tag.
+ *	The return value indicates if the tagOrId expression was successfully
+ *	scanned (syntax). The information at *searchPtr is initialized such
+ *	that a call to TagSearchFirst, followed by successive calls to
+ *	TagSearchNext will return items that match tag.
  *
  * Side effects:
  *
@@ -3200,13 +3190,12 @@ TagSearchScanExpr(interp, searchPtr, expr)
     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 */
+    int looking_for_tag;	/* When true, scanner expects next char(s) to
+				 * be a tag, else operand expected */
     int found_tag;		/* One or more tags found */
     int found_endquote;		/* For quoted tag string parsing */
     int negate_result;		/* Pending negation of next tag value */
-    char *tag;			/* tag from tag expression string */
+    char *tag;			/* Tag from tag expression string */
     char c;
     SearchUids *searchUids;	/* Collection of uids for basic search
 				 * expression terms. */
@@ -3259,9 +3248,10 @@ TagSearchScanExpr(interp, searchPtr, expr)
 		}
 		if (TagSearchScanExpr(interp, searchPtr, expr) != TCL_OK) {
 		    /*
-		     * Result string should be already set by nested
-		     * call to tag_expr_scan()
+		     * Result string should be already set by nested call to
+		     * tag_expr_scan()
 		     */
+
 		    return TCL_ERROR;
 		}
 		looking_for_tag = 0;
@@ -3325,7 +3315,11 @@ TagSearchScanExpr(interp, searchPtr, expr)
 		}
 		tag = searchPtr->rewritebuffer;
 		*tag++ = c;
-		/* copy rest of tag, including any embedded whitespace */
+
+		/*
+		 * Copy rest of tag, including any embedded whitespace.
+		 */
+
 		while (searchPtr->stringIndex < searchPtr->stringLength) {
 		    c = searchPtr->string[searchPtr->stringIndex];
 		    if (c == '!' || c == '&' || c == '|' || c == '^'
@@ -3335,11 +3329,19 @@ TagSearchScanExpr(interp, searchPtr, expr)
 		    *tag++ = c;
 		    searchPtr->stringIndex++;
 		}
-		/* remove trailing whitespace */
+
+		/*
+		 * Remove trailing whitespace.
+		 */
+
 		while (1) {
 		    c = *--tag;
-		    /* there must have been one non-whitespace char,
-		     *  so this will terminate */
+
+		    /*
+		     * There must have been one non-whitespace char, so this
+		     * will terminate.
+		     */
+
 		    if (c != ' ' && c != '\t' && c != '\n' && c != '\r') {
 			break;
 		    }
@@ -3400,7 +3402,8 @@ TagSearchScanExpr(interp, searchPtr, expr)
 	    }
 	}
     }
-    breakwhile:
+
+  breakwhile:
     if (found_tag && ! looking_for_tag) {
 	return TCL_OK;
     }
@@ -3414,11 +3417,11 @@ TagSearchScanExpr(interp, searchPtr, expr)
  *
  * TagSearchEvalExpr --
  *
- *	This recursive procedure is called to eval a tag expression.
+ *	This recursive function is called to eval a tag expression.
  *
  * Results:
- *	The return value indicates if the tagOrId expression
- *	successfully matched the tags of the current item.
+ *	The return value indicates if the tagOrId expression successfully
+ *	matched the tags of the current item.
  *
  * Side effects:
  *
@@ -3430,9 +3433,8 @@ TagSearchEvalExpr(expr, itemPtr)
     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 */
+    int looking_for_tag;	/* When true, scanner expects next char(s) to
+				 * be a tag, else operand expected. */
     int negate_result;		/* Pending negation of next tag value */
     Tk_Uid uid;
     Tk_Uid *tagPtr;
@@ -3456,11 +3458,13 @@ TagSearchEvalExpr(expr, itemPtr)
  */
 		uid = expr->uids[expr->index++];
 		result = 0;
+
 		/*
 		 * set result 1 if tag is found in item's tags
 		 */
+
 		for (tagPtr = itemPtr->tagPtr, count = itemPtr->numTags;
-		     count > 0; tagPtr++, count--) {
+			count > 0; tagPtr++, count--) {
 		    if (*tagPtr == uid) {
 			result = 1;
 			break;
@@ -3474,11 +3478,13 @@ TagSearchEvalExpr(expr, itemPtr)
  */
 		uid = expr->uids[expr->index++];
 		result = 0;
+
 		/*
 		 * set result 1 if tag is found in item's tags
 		 */
+
 		for (tagPtr = itemPtr->tagPtr, count = itemPtr->numTags;
-		     count > 0; tagPtr++, count--) {
+			count > 0; tagPtr++, count--) {
 		    if (*tagPtr == uid) {
 			result = 1;
 			break;
@@ -3487,15 +3493,18 @@ TagSearchEvalExpr(expr, itemPtr)
 
 	    } else if (uid == searchUids->parenUid) {
 		/*
-		 * evaluate subexpressions with recursion
+		 * Evaluate subexpressions with recursion
 		 */
+
 		result = TagSearchEvalExpr(expr, itemPtr);
 
 	    } else if (uid == searchUids->negparenUid) {
 		negate_result = ! negate_result;
+
 		/*
-		 * evaluate subexpressions with recursion
+		 * Evaluate subexpressions with recursion
 		 */
+
 		result = TagSearchEvalExpr(expr, itemPtr);
 /*
  *	    } else {
@@ -3511,11 +3520,11 @@ TagSearchEvalExpr(expr, itemPtr)
 	    if (((uid == searchUids->andUid) && (!result)) ||
 		    ((uid == searchUids->orUid) && result)) {
 		/*
-		 * short circuit expression evaluation
+		 * Short circuit expression evaluation.
 		 *
-		 * if result before && is 0, or result before || is 1,
-		 *   then the expression is decided and no further
-		 *   evaluation is needed.
+		 * if result before && is 0, or result before || is 1, then
+		 * the expression is decided and no further evaluation is
+		 * needed.
 		 */
 
 		parendepth = 0;
@@ -3530,7 +3539,7 @@ TagSearchEvalExpr(expr, itemPtr)
 			    uid == searchUids->negparenUid) {
 			parendepth++;
 			continue;
-		    } 
+		    }
 		    if (uid == searchUids->endparenUid) {
 			parendepth--;
 			if (parendepth < 0) {
@@ -3542,9 +3551,9 @@ TagSearchEvalExpr(expr, itemPtr)
 
 	    } else if (uid == searchUids->xorUid) {
 		/*
-		 * if the previous result was 1 then negate the next
-		 * result.
+		 * If the previous result was 1 then negate the next result.
 		 */
+
 		negate_result = result;
 
 	    } else if (uid == searchUids->endparenUid) {
@@ -3568,42 +3577,43 @@ TagSearchEvalExpr(expr, itemPtr)
  *
  * TagSearchFirst --
  *
- *	This procedure is called to get the first item item that
- *	matches a preestablished search predicate that was set by
- *	TagSearchScan.
+ *	This function is called to get the first item item that matches a
+ *	preestablished search predicate that was set by TagSearchScan.
  *
  * Results:
- *	The return value is a pointer to the first item, or NULL if
- *	there is no such item.  The information at *searchPtr is
- *	updated such that successive calls to TagSearchNext will
- *	return successive items.
+ *	The return value is a pointer to the first item, or NULL if there is
+ *	no such item. The information at *searchPtr is updated such that
+ *	successive calls to TagSearchNext will return successive items.
  *
  * Side effects:
- *	SearchPtr is linked into a list of searches in progress on
- *	canvasPtr, so that elements can safely be deleted while the
- *	search is in progress.
+ *	SearchPtr is linked into a list of searches in progress on canvasPtr,
+ *	so that elements can safely be deleted while the search is in
+ *	progress.
  *
  *--------------------------------------------------------------
  */
 
 static Tk_Item *
 TagSearchFirst(searchPtr)
-    TagSearch *searchPtr;		/* Record describing tag search */
+    TagSearch *searchPtr;	/* Record describing tag search */
 {
     Tk_Item *itemPtr, *lastPtr;
     Tk_Uid uid, *tagPtr;
     int count;
 
-    /* short circuit impossible searches for null tags */
+    /*
+     * Short circuit impossible searches for null tags.
+     */
+
     if (searchPtr->stringLength == 0) {
 	return NULL;
     }
 
     /*
-     * Find the first matching item in one of several ways. If the tag
-     * is a number then it selects the single item with the matching
-     * identifier.  In this case see if the item being requested is the
-     * hot item, in which case the search can be skipped.
+     * Find the first matching item in one of several ways. If the tag is a
+     * number then it selects the single item with the matching identifier.
+     * In this case see if the item being requested is the hot item, in which
+     * case the search can be skipped.
      */
 
     if (searchPtr->type == SEARCH_TYPE_ID) {
@@ -3659,7 +3669,7 @@ TagSearchFirst(searchPtr)
     } else {
 
 	/*
-	 * None of the above.  Search for an item matching the tag expression.
+	 * None of the above. Search for an item matching the tag expression.
 	 */
 
 	for (lastPtr = NULL, itemPtr = searchPtr->canvasPtr->firstItemPtr;
@@ -3682,15 +3692,15 @@ TagSearchFirst(searchPtr)
  *
  * TagSearchNext --
  *
- *	This procedure returns successive items that match a given
- *	tag;  it should be called only after TagSearchFirst has been
- *	used to begin a search.
+ *	This function returns successive items that match a given tag; it
+ *	should be called only after TagSearchFirst has been used to begin a
+ *	search.
  *
  * Results:
- *	The return value is a pointer to the next item that matches
- *	the tag expr specified to TagSearchScan, or NULL if no such
- *	item exists.  *SearchPtr is updated so that the next call
- *	to this procedure will return the next item.
+ *	The return value is a pointer to the next item that matches the tag
+ *	expr specified to TagSearchScan, or NULL if no such item exists.
+ *	*SearchPtr is updated so that the next call to this function will
+ *	return the next item.
  *
  * Side effects:
  *	None.
@@ -3700,16 +3710,15 @@ TagSearchFirst(searchPtr)
 
 static Tk_Item *
 TagSearchNext(searchPtr)
-    TagSearch *searchPtr;		/* Record describing search in
-					 * progress. */
+    TagSearch *searchPtr;	/* Record describing search in progress. */
 {
     Tk_Item *itemPtr, *lastPtr;
     Tk_Uid uid, *tagPtr;
     int count;
 
     /*
-     * Find next item in list (this may not actually be a suitable
-     * one to return), and return if there are no items left.
+     * Find next item in list (this may not actually be a suitable one to
+     * return), and return if there are no items left.
      */
 
     lastPtr = searchPtr->lastPtr;
@@ -3724,10 +3733,10 @@ TagSearchNext(searchPtr)
     }
     if (itemPtr != searchPtr->currentPtr) {
 	/*
-	 * The structure of the list has changed.  Probably the
-	 * previously-returned item was removed from the list.  In
-	 * this case, don't advance lastPtr; just return its new
-	 * successor (i.e. do nothing here).
+	 * The structure of the list has changed. Probably the previously-
+	 * returned item was removed from the list. In this case, don't
+	 * advance lastPtr; just return its new successor (i.e. do nothing
+	 * here).
 	 */
     } else {
 	lastPtr = itemPtr;
@@ -3788,29 +3797,27 @@ TagSearchNext(searchPtr)
  *
  * DoItem --
  *
- *	This is a utility procedure called by FindItems.  It
- *	either adds itemPtr's id to the result forming in interp,
- *	or it adds a new tag to itemPtr, depending on the value
- *	of tag.
+ *	This is a utility function called by FindItems. It either adds
+ *	itemPtr's id to the result forming in interp, or it adds a new tag to
+ *	itemPtr, depending on the value of tag.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	If tag is NULL then itemPtr's id is added as a list element
- *	to the interp's result;  otherwise tag is added to itemPtr's
- *	list of tags.
+ *	If tag is NULL then itemPtr's id is added as a list element to the
+ *	interp's result; otherwise tag is added to itemPtr's list of tags.
  *
  *--------------------------------------------------------------
  */
 
 static void
 DoItem(interp, itemPtr, tag)
-    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 item, or NULL. */
+    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
+				 * item, or NULL. */
 {
     Tk_Uid *tagPtr;
     int count;
@@ -3835,8 +3842,7 @@ DoItem(interp, itemPtr, tag)
     }
 
     /*
-     * Grow the tag space if there's no more room left in the current
-     * block.
+     * Grow the tag space if there's no more room left in the current block.
      */
 
     if (itemPtr->tagSpace == itemPtr->numTags) {
@@ -3867,22 +3873,20 @@ DoItem(interp, itemPtr, tag)
  *
  * FindItems --
  *
- *	This procedure does all the work of implementing the
- *	"find" and "addtag" options of the canvas widget command,
- *	which locate items that have certain features (location,
- *	tags, position in display list, etc.).
+ *	This function does all the work of implementing the "find" and
+ *	"addtag" options of the canvas widget command, which locate items that
+ *	have certain features (location, tags, position in display list, etc.)
  *
  * Results:
- *	A standard Tcl return value.  If newTag is NULL, then a
- *	list of ids from all the items that match objc/objv is
- *	returned in the interp's result.  If newTag is NULL, then
- *	the normal the interp's result is an empty string.  If an error
- *	occurs, then the interp's result will hold an error message.
+ *	A standard Tcl return value. If newTag is NULL, then a list of ids
+ *	from all the items that match objc/objv is returned in the interp's
+ *	result. If newTag is NULL, then the normal the interp's result is an
+ *	empty string. If an error occurs, then the interp's result will hold
+ *	an error message.
  *
  * Side effects:
- *	If newTag is non-NULL, then all the items that match the
- *	information in objc/objv have that tag added to their
- *	lists of tags.
+ *	If newTag is non-NULL, then all the items that match the information
+ *	in objc/objv have that tag added to their lists of tags.
  *
  *--------------------------------------------------------------
  */
@@ -3893,23 +3897,22 @@ 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 than zero. */
-    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 found items;  if NULL, then
-					 * ids of found items are returned
-					 * in the interp's result. */
-    int first;				/* For error messages:  gives number
-					 * of elements of objv which are already
-					 * handled. */
+    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
+				 * search for (see user doc on "find" and
+				 * "addtag" options). */
+    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
+				 * 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
@@ -4021,11 +4024,11 @@ FindItems(interp, canvasPtr, objc, objv, newTag, first, searchPtrPtr)
 	}
 
 	/*
-	 * The code below is optimized so that it can eliminate most
-	 * items without having to call their item-specific procedures.
-	 * This is done by keeping a bounding box (x1, y1, x2, y2) that
-	 * an item's bbox must overlap if the item is to have any
-	 * chance of being closer than the closest so far.
+	 * The code below is optimized so that it can eliminate most items
+	 * without having to call their item-specific functions. This is done
+	 * by keeping a bounding box (x1, y1, x2, y2) that an item's bbox must
+	 * overlap if the item is to have any chance of being closer than the
+	 * closest so far.
 	 */
 
 	itemPtr = startPtr;
@@ -4046,8 +4049,8 @@ FindItems(interp, canvasPtr, objc, objv, newTag, first, searchPtrPtr)
 	    double newDist;
 
 	    /*
-	     * Update the bounding box using itemPtr, which is the
-	     * new closest item.
+	     * Update the bounding box using itemPtr, which is the new closest
+	     * item.
 	     */
 
 	    x1 = (int) (coords[0] - closestDist - halo - 1);
@@ -4057,9 +4060,9 @@ FindItems(interp, canvasPtr, objc, objv, newTag, first, searchPtrPtr)
 	    closestPtr = itemPtr;
 
 	    /*
-	     * Search for an item that beats the current closest one.
-	     * Work circularly through the canvas's item list until
-	     * getting back to the starting item.
+	     * Search for an item that beats the current closest one. Work
+	     * circularly through the canvas's item list until getting back to
+	     * the starting item.
 	     */
 
 	    while (1) {
@@ -4123,41 +4126,37 @@ FindItems(interp, canvasPtr, objc, objv, newTag, first, searchPtrPtr)
  *
  * FindArea --
  *
- *	This procedure implements area searches for the "find"
- *	and "addtag" options.
+ *	This function implements area searches for the "find" and "addtag"
+ *	options.
  *
  * Results:
- *	A standard Tcl return value.  If newTag is NULL, then a
- *	list of ids from all the items overlapping or enclosed
- *	by the rectangle given by objc is returned in the interp's result.
- *	If newTag is NULL, then the normal the interp's result is an
- *	empty string.  If an error occurs, then the interp's result will
- *	hold an error message.
+ *	A standard Tcl return value. If newTag is NULL, then a list of ids
+ *	from all the items overlapping or enclosed by the rectangle given by
+ *	objc is returned in the interp's result. If newTag is NULL, then the
+ *	normal the interp's result is an empty string. If an error occurs,
+ *	then the interp's result will hold an error message.
  *
  * Side effects:
- *	If uid is non-NULL, then all the items overlapping
- *	or enclosed by the area in objv have that tag added to
- *	their lists of tags.
+ *	If uid is non-NULL, then all the items overlapping or enclosed by the
+ *	area in objv have that tag added to their lists of tags.
  *
  *--------------------------------------------------------------
  */
 
 static int
 FindArea(interp, canvasPtr, objv, uid, enclosed)
-    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 coordinates of the
-					 * rectangular area to search. */
-    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 OK, 1 means only enclosed
-					 * items are OK. */
+    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
+				 * coordinates of the rectangular area to
+				 * search. */
+    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
+				 * OK, 1 means only enclosed items are OK. */
 {
     double rect[4], tmp;
     int x1, y1, x2, y2;
@@ -4181,8 +4180,8 @@ FindArea(interp, canvasPtr, objv, uid, enclosed)
     }
 
     /*
-     * Use an integer bounding box for a quick test, to avoid
-     * calling item-specific code except for items that are close.
+     * Use an integer bounding box for a quick test, to avoid calling
+     * item-specific code except for items that are close.
      */
 
     x1 = (int) (rect[0]-1.0);
@@ -4212,17 +4211,16 @@ FindArea(interp, canvasPtr, objv, uid, enclosed)
  *
  * RelinkItems --
  *
- *	Move one or more items to a different place in the
- *	display order for a canvas.
+ *	Move one or more items to a different place in the display order for a
+ *	canvas.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The items identified by "tag" are moved so that they
- *	are all together in the display list and immediately
- *	after prevPtr.  The order of the moved items relative
- *	to each other is not changed.
+ *	The items identified by "tag" are moved so that they are all together
+ *	in the display list and immediately after prevPtr. The order of the
+ *	moved items relative to each other is not changed.
  *
  *--------------------------------------------------------------
  */
@@ -4235,11 +4233,11 @@ 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 redisplay list. */
-    Tk_Item *prevPtr;		/* Reposition the items so that they
-				 * go just after this item (NULL means
-				 * put at beginning of list). */
+    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). */
 #ifndef USE_OLD_TAG_SEARCH
     TagSearch **searchPtrPtr;   /* From CanvasWidgetCmd local vars */
 #endif /* not USE_OLD_TAG_SEARCH */
@@ -4252,17 +4250,17 @@ RelinkItems(canvasPtr, tag, prevPtr, searchPtrPtr)
     int result;
 
     /*
-     * Find all of the items to be moved and remove them from
-     * the list, making an auxiliary list running from firstMovePtr
-     * to lastMovePtr.  Record their areas for redisplay.
+     * Find all of the items to be moved and remove them from the list, making
+     * an auxiliary list running from firstMovePtr to lastMovePtr. Record
+     * their areas for redisplay.
      */
 
     firstMovePtr = lastMovePtr = NULL;
     FOR_EVERY_CANVAS_ITEM_MATCHING(tag, searchPtrPtr, return TCL_ERROR) {
 	if (itemPtr == prevPtr) {
 	    /*
-	     * Item after which insertion is to occur is being
-	     * moved!  Switch to insert after its predecessor.
+	     * Item after which insertion is to occur is being moved! Switch
+	     * to insert after its predecessor.
 	     */
 
 	    prevPtr = prevPtr->prevPtr;
@@ -4294,8 +4292,8 @@ RelinkItems(canvasPtr, tag, prevPtr, searchPtrPtr)
     }
 
     /*
-     * Insert the list of to-be-moved items back into the canvas's
-     * at the desired position.
+     * Insert the list of to-be-moved items back into the canvas's at the
+     * desired position.
      */
 
     if (firstMovePtr == NULL) {
@@ -4334,24 +4332,23 @@ RelinkItems(canvasPtr, tag, prevPtr, searchPtrPtr)
  *
  * CanvasBindProc --
  *
- *	This procedure is invoked by the Tk dispatcher to handle
- *	events associated with bindings on items.
+ *	This function is invoked by the Tk dispatcher to handle events
+ *	associated with bindings on items.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Depends on the command invoked as part of the binding
- *	(if there was any).
+ *	Depends on the command invoked as part of the binding (if there was
+ *	any).
  *
  *--------------------------------------------------------------
  */
 
 static void
 CanvasBindProc(clientData, eventPtr)
-    ClientData clientData;		/* Pointer to canvas structure. */
-    XEvent *eventPtr;			/* Pointer to X event that just
-					 * happened. */
+    ClientData clientData;	/* Pointer to canvas structure. */
+    XEvent *eventPtr;		/* Pointer to X event that just happened. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) clientData;
 
@@ -4359,8 +4356,8 @@ CanvasBindProc(clientData, eventPtr)
 
     /*
      * This code below keeps track of the current modifier state in
-     * canvasPtr>state.  This information is used to defer repicks of
-     * the current item while buttons are down.
+     * canvasPtr>state. This information is used to defer repicks of the
+     * current item while buttons are down.
      */
 
     if ((eventPtr->type == ButtonPress) || (eventPtr->type == ButtonRelease)) {
@@ -4388,18 +4385,17 @@ CanvasBindProc(clientData, eventPtr)
 	}
 
 	/*
-	 * For button press events, repick the current item using the
-	 * button state before the event, then process the event.  For
-	 * button release events, first process the event, then repick
-	 * the current item using the button state *after* the event
-	 * (the button has logically gone up before we change the
-	 * current item).
+	 * For button press events, repick the current item using the button
+	 * state before the event, then process the event. For button release
+	 * events, first process the event, then repick the current item using
+	 * the button state *after* the event (the button has logically gone
+	 * up before we change the current item).
 	 */
 
 	if (eventPtr->type == ButtonPress) {
 	    /*
-	     * On a button press, first repick the current item using
-	     * the button state before the event, the process the event.
+	     * On a button press, first repick the current item using the
+	     * button state before the event, the process the event.
 	     */
 
 	    canvasPtr->state = eventPtr->xbutton.state;
@@ -4408,9 +4404,9 @@ CanvasBindProc(clientData, eventPtr)
 	    CanvasDoEvent(canvasPtr, eventPtr);
 	} else {
 	    /*
-	     * Button release: first process the event, with the button
-	     * still considered to be down.  Then repick the current
-	     * item under the assumption that the button is no longer down.
+	     * Button release: first process the event, with the button still
+	     * considered to be down. Then repick the current item under the
+	     * assumption that the button is no longer down.
 	     */
 
 	    canvasPtr->state = eventPtr->xbutton.state;
@@ -4441,34 +4437,31 @@ CanvasBindProc(clientData, eventPtr)
  *
  * PickCurrentItem --
  *
- *	Find the topmost item in a canvas that contains a given
- *	location and mark the the current item.  If the current
- *	item has changed, generate a fake exit event on the old
- *	current item, a fake enter event on the new current item
- *	item and force a redraw of the two items. Canvas items
+ *	Find the topmost item in a canvas that contains a given location and
+ *	mark the the current item. If the current item has changed, generate a
+ *	fake exit event on the old current item, a fake enter event on the new
+ *	current item item and force a redraw of the two items. Canvas items
  *	that are hidden or disabled are ignored.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The current item for canvasPtr may change.  If it does,
- *	then the commands associated with item entry and exit
- *	could do just about anything.  A binding script could
- *	delete the canvas, so callers should protect themselves
- *	with Tcl_Preserve and Tcl_Release.
+ *	The current item for canvasPtr may change. If it does, then the
+ *	commands associated with item entry and exit could do just about
+ *	anything. A binding script could delete the canvas, so callers should
+ *	protect themselves with Tcl_Preserve and Tcl_Release.
  *
  *--------------------------------------------------------------
  */
 
 static void
 PickCurrentItem(canvasPtr, eventPtr)
-    TkCanvas *canvasPtr;		/* Canvas widget in which to select
-					 * current item. */
-    XEvent *eventPtr;			/* Event describing location of
-					 * mouse cursor.  Must be EnterWindow,
-					 * LeaveWindow, ButtonRelease, or
-					 * MotionNotify. */
+    TkCanvas *canvasPtr;	/* Canvas widget in which to select current
+				 * item. */
+    XEvent *eventPtr;		/* Event describing location of mouse cursor.
+				 * Must be EnterWindow, LeaveWindow,
+				 * ButtonRelease, or MotionNotify. */
 {
     double coords[2];
     int buttonDown;
@@ -4478,10 +4471,10 @@ PickCurrentItem(canvasPtr, eventPtr)
 #endif
 
     /*
-     * Check whether or not a button is down.  If so, we'll log entry
-     * and exit into and out of the current item, but not entry into
-     * any other item.  This implements a form of grabbing equivalent
-     * to what the X server does for windows.
+     * Check whether or not a button is down. If so, we'll log entry and exit
+     * into and out of the current item, but not entry into any other item.
+     * This implements a form of grabbing equivalent to what the X server does
+     * for windows.
      */
 
     buttonDown = canvasPtr->state
@@ -4491,13 +4484,14 @@ PickCurrentItem(canvasPtr, eventPtr)
     }
 
     /*
-     * Save information about this event in the canvas.  The event in
-     * the canvas is used for two purposes:
+     * Save information about this event in the canvas. The event in the
+     * canvas is used for two purposes:
      *
      * 1. Event bindings: if the current item changes, fake events are
      *    generated to allow item-enter and item-leave bindings to trigger.
-     * 2. Reselection: if the current item gets deleted, can use the
-     *    saved event to find a new current item.
+     * 2. Reselection: if the current item gets deleted, can use the saved
+     *    event to find a new current item.
+     *
      * Translate MotionNotify events into EnterNotify events, since that's
      * what gets reported to item handlers.
      */
@@ -4530,10 +4524,10 @@ PickCurrentItem(canvasPtr, eventPtr)
     }
 
     /*
-     * If this is a recursive call (there's already a partially completed
-     * call pending on the stack;  it's in the middle of processing a
-     * Leave event handler for the old current item) then just return;
-     * the pending call will do everything that's needed.
+     * If this is a recursive call (there's already a partially completed call
+     * pending on the stack; it's in the middle of processing a Leave event
+     * handler for the old current item) then just return; the pending call
+     * will do everything that's needed.
      */
 
     if (canvasPtr->flags & REPICK_IN_PROGRESS) {
@@ -4541,8 +4535,8 @@ PickCurrentItem(canvasPtr, eventPtr)
     }
 
     /*
-     * A LeaveNotify event automatically means that there's no current
-     * object, so the check for closest item can be skipped.
+     * A LeaveNotify event automatically means that there's no current object,
+     * so the check for closest item can be skipped.
      */
 
     coords[0] = canvasPtr->pickEvent.xcrossing.x + canvasPtr->xOrigin;
@@ -4563,10 +4557,9 @@ PickCurrentItem(canvasPtr, eventPtr)
     }
 
     /*
-     * Simulate a LeaveNotify event on the previous current item and
-     * an EnterNotify event on the new current item.  Remove the "current"
-     * tag from the previous current item and place it on the new current
-     * item.
+     * Simulate a LeaveNotify event on the previous current item and an
+     * EnterNotify event on the new current item. Remove the "current" tag
+     * from the previous current item and place it on the new current item.
      */
 
     if ((canvasPtr->newCurrentPtr != canvasPtr->currentItemPtr)
@@ -4580,9 +4573,9 @@ PickCurrentItem(canvasPtr, eventPtr)
 	event.type = LeaveNotify;
 
 	/*
-	 * If the event's detail happens to be NotifyInferior the
-	 * binding mechanism will discard the event.  To be consistent,
-	 * always use NotifyAncestor.
+	 * If the event's detail happens to be NotifyInferior the binding
+	 * mechanism will discard the event. To be consistent, always use
+	 * NotifyAncestor.
 	 */
 
 	event.xcrossing.detail = NotifyAncestor;
@@ -4591,8 +4584,8 @@ PickCurrentItem(canvasPtr, eventPtr)
 	canvasPtr->flags &= ~REPICK_IN_PROGRESS;
 
 	/*
-	 * The check below is needed because there could be an event
-	 * handler for <LeaveNotify> that deletes the current item.
+	 * The check below is needed because there could be an event handler
+	 * for <LeaveNotify> that deletes the current item.
 	 */
 
 	if ((itemPtr == canvasPtr->currentItemPtr) && !buttonDown) {
@@ -4609,11 +4602,11 @@ PickCurrentItem(canvasPtr, eventPtr)
 		}
 	    }
 	}
-    
+
 	/*
-	 * Note:  during CanvasDoEvent above, it's possible that
-	 * canvasPtr->newCurrentPtr got reset to NULL because the
-	 * item was deleted.
+	 * Note: during CanvasDoEvent above, it's possible that
+	 * canvasPtr->newCurrentPtr got reset to NULL because the item was
+	 * deleted.
 	 */
     }
     if ((canvasPtr->newCurrentPtr != canvasPtr->currentItemPtr) && buttonDown) {
@@ -4622,9 +4615,9 @@ PickCurrentItem(canvasPtr, eventPtr)
     }
 
     /*
-     * Special note:  it's possible that canvasPtr->newCurrentPtr ==
-     * canvasPtr->currentItemPtr here.  This can happen, for example,
-     * if LEFT_GRABBED_ITEM was set.
+     * Special note: it's possible that canvasPtr->newCurrentPtr ==
+     * canvasPtr->currentItemPtr here. This can happen, for example, if
+     * LEFT_GRABBED_ITEM was set.
      */
 
     prevItemPtr = canvasPtr->currentItemPtr;
@@ -4641,7 +4634,7 @@ PickCurrentItem(canvasPtr, eventPtr)
 	XEvent event;
 
 #ifdef USE_OLD_TAG_SEARCH
-	DoItem((Tcl_Interp *) NULL, canvasPtr->currentItemPtr, 
+	DoItem((Tcl_Interp *) NULL, canvasPtr->currentItemPtr,
 		Tk_GetUid("current"));
 #else /* USE_OLD_TAG_SEARCH */
 	DoItem((Tcl_Interp *) NULL, canvasPtr->currentItemPtr,
@@ -4667,13 +4660,13 @@ PickCurrentItem(canvasPtr, eventPtr)
  *
  * CanvasFindClosest --
  *
- *	Given x and y coordinates, find the topmost canvas item that
- *	is "close" to the coordinates. Canvas items that are hidden
- *	or disabled are ignored.
+ *	Given x and y coordinates, find the topmost canvas item that is
+ *	"close" to the coordinates. Canvas items that are hidden or disabled
+ *	are ignored.
  *
  * Results:
- *	The return value is a pointer to the topmost item that is
- *	close to (x,y), or NULL if no item is close.
+ *	The return value is a pointer to the topmost item that is close to
+ *	(x,y), or NULL if no item is close.
  *
  * Side effects:
  *	None.
@@ -4683,9 +4676,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, coordinates.) */
+    TkCanvas *canvasPtr;	/* Canvas widget to search. */
+    double coords[2];		/* Desired x,y position in canvas, not screen,
+				 * coordinates.) */
 {
     Tk_Item *itemPtr;
     Tk_Item *bestPtr;
@@ -4721,27 +4714,25 @@ CanvasFindClosest(canvasPtr, coords)
  *
  * CanvasDoEvent --
  *
- *	This procedure is called to invoke binding processing
- *	for a new event that is associated with the current item
- *	for a canvas.
+ *	This function is called to invoke binding processing for a new event
+ *	that is associated with the current item for a canvas.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Depends on the bindings for the canvas.  A binding script
- *	could delete the canvas, so callers should protect themselves
- *	with Tcl_Preserve and Tcl_Release.
+ *	Depends on the bindings for the canvas. A binding script could delete
+ *	the canvas, so callers should protect themselves with Tcl_Preserve and
+ *	Tcl_Release.
  *
  *--------------------------------------------------------------
  */
 
 static void
 CanvasDoEvent(canvasPtr, eventPtr)
-    TkCanvas *canvasPtr;		/* Canvas widget in which event
-					 * occurred. */
-    XEvent *eventPtr;			/* Real or simulated X event that
-					 * is to be processed. */
+    TkCanvas *canvasPtr;	/* Canvas widget in which event occurred. */
+    XEvent *eventPtr;		/* Real or simulated X event that is to be
+				 * processed. */
 {
 #define NUM_STATIC 3
     ClientData staticObjects[NUM_STATIC];
@@ -4768,30 +4759,30 @@ CanvasDoEvent(canvasPtr, eventPtr)
 
 #ifdef USE_OLD_TAG_SEARCH
     /*
-     * Set up an array with all the relevant objects for processing
-     * this event.  The relevant objects are (a) the event's item,
-     * (b) the tags associated with the event's item, and (c) the
-     * tag "all".  If there are a lot of tags then malloc an array
-     * to hold all of the objects.
+     * Set up an array with all the relevant objects for processing this
+     * event. The relevant objects are (a) the event's item, (b) the tags
+     * associated with the event's item, and (c) the tag "all". If there are a
+     * lot of tags then malloc an array to hold all of the objects.
      */
 
     numObjects = itemPtr->numTags + 2;
 #else /* USE_OLD_TAG_SEARCH */
     /*
-     * Set up an array with all the relevant objects for processing
-     * this event.  The relevant objects are:
+     * Set up an array with all the relevant objects for processing this
+     * event. The relevant objects are:
      * (a) the event's item,
-     * (b) the tags associated with the event's item, 
+     * (b) the tags associated with the event's item,
      * (c) the expressions that are true for the event's item's tags, and
-     * (d) the tag "all". 
+     * (d) the tag "all".
      *
-     * If there are a lot of tags then malloc an array to hold all of
-     * the objects.
+     * If there are a lot of tags then malloc an array to hold all of the
+     * objects.
      */
 
     /*
-     * flag and count all expressions that match item's tags
+     * Flag and count all expressions that match item's tags.
      */
+
     numExprs = 0;
     expr = canvasPtr->bindTagExprs;
     while (expr) {
@@ -4820,10 +4811,12 @@ CanvasDoEvent(canvasPtr, eventPtr)
 	objectPtr[i+1] = (ClientData) itemPtr->tagPtr[i];
     }
     objectPtr[itemPtr->numTags+1] = (ClientData) itemPtr;
+
 #ifndef USE_OLD_TAG_SEARCH
     /*
-     * copy uids of matching expressions into object array
+     * Copy uids of matching expressions into object array
      */
+
     i = itemPtr->numTags+2;
     expr = canvasPtr->bindTagExprs;
     while (expr) {
@@ -4835,8 +4828,8 @@ CanvasDoEvent(canvasPtr, eventPtr)
 #endif /* not USE_OLD_TAG_SEARCH */
 
     /*
-     * Invoke the binding system, then free up the object array if
-     * it was malloc-ed.
+     * Invoke the binding system, then free up the object array if it was
+     * malloc-ed.
      */
 
     if (canvasPtr->tkwin != NULL) {
@@ -4853,15 +4846,15 @@ CanvasDoEvent(canvasPtr, eventPtr)
  *
  * CanvasBlinkProc --
  *
- *	This procedure is called as a timer handler to blink the
- *	insertion cursor off and on.
+ *	This function is called as a timer handler to blink the insertion
+ *	cursor off and on.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The cursor gets turned on or off, redisplay gets invoked,
- *	and this procedure reschedules itself.
+ *	The cursor gets turned on or off, redisplay gets invoked, and this
+ *	function reschedules itself.
  *
  *----------------------------------------------------------------------
  */
@@ -4897,9 +4890,9 @@ CanvasBlinkProc(clientData)
  *
  * CanvasFocusProc --
  *
- *	This procedure is called whenever a canvas gets or loses the
- *	input focus.  It's also called whenever the window is
- *	reconfigured while it has the focus.
+ *	This function is called whenever a canvas gets or loses the input
+ *	focus. It's also called whenever the window is reconfigured while it
+ *	has the focus.
  *
  * Results:
  *	None.
@@ -4948,8 +4941,8 @@ CanvasFocusProc(canvasPtr, gotFocus)
  *
  * CanvasSelectTo --
  *
- *	Modify the selection by moving its un-anchored end.  This could
- *	make the selection either larger or smaller.
+ *	Modify the selection by moving its un-anchored end. This could make
+ *	the selection either larger or smaller.
  *
  * Results:
  *	None.
@@ -5010,15 +5003,15 @@ CanvasSelectTo(canvasPtr, itemPtr, index)
  *
  * CanvasFetchSelection --
  *
- *	This procedure is invoked by Tk to return part or all of
- *	the selection, when the selection is in a canvas widget.
- *	This procedure always returns the selection as a STRING.
+ *	This function is invoked by Tk to return part or all of the selection,
+ *	when the selection is in a canvas widget. This function always returns
+ *	the selection as a STRING.
  *
  * Results:
- *	The return value is the number of non-NULL bytes stored
- *	at buffer.  Buffer is filled (or partially filled) with a
- *	NULL-terminated string containing part or all of the selection,
- *	as given by offset and maxBytes.
+ *	The return value is the number of non-NULL bytes stored at buffer.
+ *	Buffer is filled (or partially filled) with a NULL-terminated string
+ *	containing part or all of the selection, as given by offset and
+ *	maxBytes.
  *
  * Side effects:
  *	None.
@@ -5028,14 +5021,13 @@ 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 to be returned. */
-    char *buffer;			/* Location in which to place
-					 * selection. */
-    int maxBytes;			/* Maximum number of bytes to place
-					 * at buffer, not including terminating
-					 * NULL character. */
+    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,
+				 * not including terminating NULL
+				 * character. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) clientData;
 
@@ -5055,22 +5047,22 @@ CanvasFetchSelection(clientData, offset, buffer, maxBytes)
  *
  * CanvasLostSelection --
  *
- *	This procedure is called back by Tk when the selection is
- *	grabbed away from a canvas widget.
+ *	This function is called back by Tk when the selection is grabbed away
+ *	from a canvas widget.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The existing selection is unhighlighted, and the window is
- *	marked as not containing a selection.
+ *	The existing selection is unhighlighted, and the window is marked as
+ *	not containing a selection.
  *
  *----------------------------------------------------------------------
  */
 
 static void
 CanvasLostSelection(clientData)
-    ClientData clientData;		/* Information about entry widget. */
+    ClientData clientData;	/* Information about entry widget. */
 {
     TkCanvas *canvasPtr = (TkCanvas *) clientData;
 
@@ -5086,13 +5078,11 @@ CanvasLostSelection(clientData)
  *
  * GridAlign --
  *
- *	Given a coordinate and a grid spacing, this procedure
- *	computes the location of the nearest grid line to the
- *	coordinate.
+ *	Given a coordinate and a grid spacing, this function computes the
+ *	location of the nearest grid line to the coordinate.
  *
  * Results:
- *	The return value is the location of the grid line nearest
- *	to coord.
+ *	The return value is the location of the grid line nearest to coord.
  *
  * Side effects:
  *	None.
@@ -5103,8 +5093,8 @@ CanvasLostSelection(clientData)
 static double
 GridAlign(coord, spacing)
     double coord;		/* Coordinate to grid-align. */
-    double spacing;		/* Spacing between grid lines.   If <= 0
-				 * then no alignment is done. */
+    double spacing;		/* Spacing between grid lines. If <= 0 then no
+				 * alignment is done. */
 {
     if (spacing <= 0.0) {
 	return coord;
@@ -5120,15 +5110,14 @@ GridAlign(coord, spacing)
  *
  * ScrollFractions --
  *
- *	Given the range that's visible in the window and the "100%
- *	range" for what's in the canvas, return a list of two
- *	doubles representing the scroll fractions.  This procedure
- *	is used for both x and y scrolling.
+ *	Given the range that's visible in the window and the "100% range" for
+ *	what's in the canvas, return a list of two doubles representing the
+ *	scroll fractions. This function is used for both x and y scrolling.
  *
  * Results:
- *	A List Tcl_Obj with two real numbers (Double Tcl_Objs)
- *	containing the scroll fractions (between 0 and 1)
- *	corresponding to the other arguments.
+ *	A List Tcl_Obj with two real numbers (Double Tcl_Objs) containing the
+ *	scroll fractions (between 0 and 1) corresponding to the other
+ *	arguments.
  *
  * Side effects:
  *	None.
@@ -5173,18 +5162,17 @@ ScrollFractions(screen1, screen2, object1, object2)
  *
  * CanvasUpdateScrollbars --
  *
- *	This procedure is invoked whenever a canvas has changed in
- *	a way that requires scrollbars to be redisplayed (e.g. the
- *	view in the canvas has changed).
+ *	This function is invoked whenever a canvas has changed in a way that
+ *	requires scrollbars to be redisplayed (e.g. the view in the canvas has
+ *	changed).
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	If there are scrollbars associated with the canvas, then
- *	their scrolling commands are invoked to cause them to
- *	redisplay.  If errors occur, additional Tcl commands may
- *	be invoked to process the errors.
+ *	If there are scrollbars associated with the canvas, then their
+ *	scrolling commands are invoked to cause them to redisplay. If errors
+ *	occur, additional Tcl commands may be invoked to process the errors.
  *
  *--------------------------------------------------------------
  */
@@ -5203,7 +5191,7 @@ CanvasUpdateScrollbars(canvasPtr)
      * Save all the relevant values from the canvasPtr, because it might be
      * deleted as part of either of the two calls to Tcl_VarEval below.
      */
-    
+
     interp = canvasPtr->interp;
     Tcl_Preserve((ClientData) interp);
     xScrollCmd = canvasPtr->xScrollCmd;
@@ -5227,8 +5215,8 @@ CanvasUpdateScrollbars(canvasPtr)
     if (canvasPtr->xScrollCmd != NULL) {
 	Tcl_Obj *fractions = ScrollFractions(xOrigin + inset,
 		xOrigin + width - inset, scrollX1, scrollX2);
-	result = Tcl_VarEval(interp, xScrollCmd, " ", 
-		Tcl_GetString(fractions), (char *) NULL);
+	result = Tcl_VarEval(interp, xScrollCmd, " ", Tcl_GetString(fractions),
+		(char *) NULL);
 	Tcl_DecrRefCount(fractions);
 	if (result != TCL_OK) {
 	    Tcl_BackgroundError(interp);
@@ -5240,8 +5228,8 @@ CanvasUpdateScrollbars(canvasPtr)
     if (yScrollCmd != NULL) {
 	Tcl_Obj *fractions = ScrollFractions(yOrigin + inset,
 		yOrigin + height - inset, scrollY1, scrollY2);
-	result = Tcl_VarEval(interp, yScrollCmd, " ", 
-		Tcl_GetString(fractions), (char *) NULL);
+	result = Tcl_VarEval(interp, yScrollCmd, " ", Tcl_GetString(fractions),
+		(char *) NULL);
 	Tcl_DecrRefCount(fractions);
 	if (result != TCL_OK) {
 	    Tcl_BackgroundError(interp);
@@ -5257,17 +5245,15 @@ CanvasUpdateScrollbars(canvasPtr)
  *
  * CanvasSetOrigin --
  *
- *	This procedure is invoked to change the mapping between
- *	canvas coordinates and screen coordinates in the canvas
- *	window.
+ *	This function is invoked to change the mapping between canvas
+ *	coordinates and screen coordinates in the canvas window.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The canvas will be redisplayed to reflect the change in
- *	view.  In addition, scrollbars will be updated if there
- *	are any.
+ *	The canvas will be redisplayed to reflect the change in view. In
+ *	addition, scrollbars will be updated if there are any.
  *
  *--------------------------------------------------------------
  */
@@ -5285,10 +5271,9 @@ CanvasSetOrigin(canvasPtr, xOrigin, yOrigin)
     int left, right, top, bottom, delta;
 
     /*
-     * If scroll increments have been set, round the window origin
-     * to the nearest multiple of the increments.  Remember, the
-     * origin is the place just inside the borders,  not the upper
-     * left corner.
+     * If scroll increments have been set, round the window origin to the
+     * nearest multiple of the increments. Remember, the origin is the place
+     * just inside the borders, not the upper left corner.
      */
 
     if (canvasPtr->xScrollIncrement > 0) {
@@ -5316,13 +5301,13 @@ CanvasSetOrigin(canvasPtr, xOrigin, yOrigin)
 
     /*
      * Adjust the origin if necessary to keep as much as possible of the
-     * canvas in the view.  The variables left, right, etc. keep track of
-     * how much extra space there is on each side of the view before it
-     * will stick out past the scroll region.  If one side sticks out past
-     * the edge of the scroll region, adjust the view to bring that side
-     * back to the edge of the scrollregion (but don't move it so much that
-     * the other side sticks out now).  If scroll increments are in effect,
-     * be sure to adjust only by full increments.
+     * canvas in the view. The variables left, right, etc. keep track of how
+     * much extra space there is on each side of the view before it will stick
+     * out past the scroll region.  If one side sticks out past the edge of
+     * the scroll region, adjust the view to bring that side back to the edge
+     * of the scrollregion (but don't move it so much that the other side
+     * sticks out now). If scroll increments are in effect, be sure to adjust
+     * only by full increments.
      */
 
     if ((canvasPtr->confine) && (canvasPtr->regionString != NULL)) {
@@ -5365,11 +5350,11 @@ CanvasSetOrigin(canvasPtr, xOrigin, yOrigin)
     }
 
     /*
-     * Tricky point: must redisplay not only everything that's visible
-     * in the window's final configuration, but also everything that was
-     * visible in the initial configuration.  This is needed because some
-     * item types, like windows, need to know when they move off-screen
-     * so they can explicitly undisplay themselves.
+     * Tricky point: must redisplay not only everything that's visible in the
+     * window's final configuration, but also everything that was visible in
+     * the initial configuration. This is needed because some item types, like
+     * windows, need to know when they move off-screen so they can explicitly
+     * undisplay themselves.
      */
 
     Tk_CanvasEventuallyRedraw((Tk_Canvas) canvasPtr,
@@ -5394,11 +5379,12 @@ CanvasSetOrigin(canvasPtr, xOrigin, yOrigin)
  *	Converts object list into string list.
  *
  * Side effects:
- *	Memory is allocated for the objv array, which must
- *	be freed using ckfree() when no longer needed.
+ *	Memory is allocated for the objv array, which must be freed using
+ *	ckfree() when no longer needed.
  *
  *----------------------------------------------------------------------
  */
+
 /* ARGSUSED */
 static CONST char **
 TkGetStringsFromObjs(objc, objv)
@@ -5423,16 +5409,15 @@ TkGetStringsFromObjs(objc, objv)
  *
  * Tk_CanvasPsColor --
  *
- *	This procedure is called by individual canvas items when
- *	they want to set a color value for output.  Given information
- *	about an X color, this procedure will generate Postscript
- *	commands to set up an appropriate color in Postscript.
+ *	This function is called by individual canvas items when they want to
+ *	set a color value for output. Given information about an X color, this
+ *	function will generate Postscript commands to set up an appropriate
+ *	color in Postscript.
  *
  * Results:
- *	Returns a standard Tcl return value.  If an error occurs
- *	then an error message will be left in interp->result.
- *	If no error occurs, then additional Postscript will be
- *	appended to interp->result.
+ *	Returns a standard Tcl return value. If an error occurs then an error
+ *	message will be left in interp->result. If no error occurs, then
+ *	additional Postscript will be appended to interp->result.
  *
  * Side effects:
  *	None.
@@ -5442,10 +5427,10 @@ TkGetStringsFromObjs(objc, objv)
 
 int
 Tk_CanvasPsColor(interp, canvas, colorPtr)
-    Tcl_Interp *interp;			/* Interpreter for returning Postscript
-					 * or error message. */
-    Tk_Canvas canvas;			/* Information about canvas. */
-    XColor *colorPtr;			/* Information about color. */
+    Tcl_Interp *interp;		/* Interpreter for returning Postscript or
+				 * error message. */
+    Tk_Canvas canvas;		/* Information about canvas. */
+    XColor *colorPtr;		/* Information about color. */
 {
     return Tk_PostscriptColor(interp, ((TkCanvas *) canvas)->psInfo,
 	    colorPtr);
@@ -5456,31 +5441,30 @@ Tk_CanvasPsColor(interp, canvas, colorPtr)
  *
  * Tk_CanvasPsFont --
  *
- *	This procedure is called by individual canvas items when
- *	they want to output text.  Given information about an X
- *	font, this procedure will generate Postscript commands
- *	to set up an appropriate font in Postscript.
+ *	This function is called by individual canvas items when they want to
+ *	output text. Given information about an X font, this function will
+ *	generate Postscript commands to set up an appropriate font in
+ *	Postscript.
  *
  * Results:
- *	Returns a standard Tcl return value.  If an error occurs
- *	then an error message will be left in interp->result.
- *	If no error occurs, then additional Postscript will be
- *	appended to the interp->result.
+ *	Returns a standard Tcl return value. If an error occurs then an error
+ *	message will be left in interp->result. If no error occurs, then
+ *	additional Postscript will be appended to the interp->result.
  *
  * Side effects:
- *	The Postscript font name is entered into psInfoPtr->fontTable
- *	if it wasn't already there.
+ *	The Postscript font name is entered into psInfoPtr->fontTable if it
+ *	wasn't already there.
  *
  *--------------------------------------------------------------
  */
 
 int
 Tk_CanvasPsFont(interp, canvas, tkfont)
-    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 be printed. */
+    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
+				 * be printed. */
 {
     return Tk_PostscriptFont(interp, ((TkCanvas *) canvas)->psInfo, tkfont);
 }
@@ -5490,16 +5474,14 @@ Tk_CanvasPsFont(interp, canvas, tkfont)
  *
  * Tk_CanvasPsBitmap --
  *
- *	This procedure is called to output the contents of a
- *	sub-region of a bitmap in proper image data format for
- *	Postscript (i.e. data between angle brackets, one bit
- *	per pixel).
+ *	This function is called to output the contents of a sub-region of a
+ *	bitmap in proper image data format for Postscript (i.e. data between
+ *	angle brackets, one bit per pixel).
  *
  * Results:
- *	Returns a standard Tcl return value.  If an error occurs
- *	then an error message will be left in interp->result.
- *	If no error occurs, then additional Postscript will be
- *	appended to interp->result.
+ *	Returns a standard Tcl return value. If an error occurs then an error
+ *	message will be left in interp->result. If no error occurs, then
+ *	additional Postscript will be appended to interp->result.
  *
  * Side effects:
  *	None.
@@ -5509,14 +5491,13 @@ Tk_CanvasPsFont(interp, canvas, tkfont)
 
 int
 Tk_CanvasPsBitmap(interp, canvas, bitmap, startX, startY, width, height)
-    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 rectangular region to output. */
-    int width, height;			/* Height of rectangular region. */
+    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
+				 * rectangular region to output. */
+    int width, height;		/* Height of rectangular region. */
 {
     return Tk_PostscriptBitmap(interp, ((TkCanvas *) canvas)->tkwin,
 	    ((TkCanvas *) canvas)->psInfo, bitmap, startX, startY,
@@ -5528,18 +5509,16 @@ Tk_CanvasPsBitmap(interp, canvas, bitmap, startX, startY, width, height)
  *
  * Tk_CanvasPsStipple --
  *
- *	This procedure is called by individual canvas items when
- *	they have created a path that they'd like to be filled with
- *	a stipple pattern.  Given information about an X bitmap,
- *	this procedure will generate Postscript commands to fill
- *	the current clip region using a stipple pattern defined by the
- *	bitmap.
+ *	This function is called by individual canvas items when they have
+ *	created a path that they'd like to be filled with a stipple pattern.
+ *	Given information about an X bitmap, this function will generate
+ *	Postscript commands to fill the current clip region using a stipple
+ *	pattern defined by the bitmap.
  *
  * Results:
- *	Returns a standard Tcl return value.  If an error occurs
- *	then an error message will be left in interp->result.
- *	If no error occurs, then additional Postscript will be
- *	appended to interp->result.
+ *	Returns a standard Tcl return value. If an error occurs then an error
+ *	message will be left in interp->result. If no error occurs, then
+ *	additional Postscript will be appended to interp->result.
  *
  * Side effects:
  *	None.
@@ -5549,10 +5528,10 @@ Tk_CanvasPsBitmap(interp, canvas, bitmap, startX, startY, width, height)
 
 int
 Tk_CanvasPsStipple(interp, canvas, bitmap)
-    Tcl_Interp *interp;			/* Interpreter for returning Postscript
-					 * or error message. */
-    Tk_Canvas canvas;			/* Information about canvas. */
-    Pixmap bitmap;			/* Bitmap to use for stippling. */
+    Tcl_Interp *interp;		/* Interpreter for returning Postscript or
+				 * error message. */
+    Tk_Canvas canvas;		/* Information about canvas. */
+    Pixmap bitmap;		/* Bitmap to use for stippling. */
 {
     return Tk_PostscriptStipple(interp, ((TkCanvas *) canvas)->tkwin,
 	    ((TkCanvas *) canvas)->psInfo, bitmap);
@@ -5563,12 +5542,11 @@ Tk_CanvasPsStipple(interp, canvas, bitmap)
  *
  * Tk_CanvasPsY --
  *
- *	Given a y-coordinate in canvas coordinates, this procedure
- *	returns a y-coordinate to use for Postscript output.
+ *	Given a y-coordinate in canvas coordinates, this function returns a
+ *	y-coordinate to use for Postscript output.
  *
  * Results:
- *	Returns the Postscript coordinate that corresponds to
- *	"y".
+ *	Returns the Postscript coordinate that corresponds to "y".
  *
  * Side effects:
  *	None.
@@ -5578,9 +5556,9 @@ Tk_CanvasPsStipple(interp, canvas, bitmap)
 
 double
 Tk_CanvasPsY(canvas, y)
-    Tk_Canvas canvas;			/* Token for canvas on whose behalf
-					 * Postscript is being generated. */
-    double y;				/* Y-coordinate in canvas coords. */
+    Tk_Canvas canvas;		/* Token for canvas on whose behalf Postscript
+				 * is being generated. */
+    double y;			/* Y-coordinate in canvas coords. */
 {
     return Tk_PostscriptY(y, ((TkCanvas *) canvas)->psInfo);
 }
@@ -5590,8 +5568,8 @@ Tk_CanvasPsY(canvas, y)
  *
  * Tk_CanvasPsPath --
  *
- *	Given an array of points for a path, generate Postscript
- *	commands to create the path.
+ *	Given an array of points for a path, generate Postscript commands to
+ *	create the path.
  *
  * Results:
  *	Postscript commands get appended to what's in interp->result.
@@ -5604,15 +5582,22 @@ Tk_CanvasPsY(canvas, y)
 
 void
 Tk_CanvasPsPath(interp, canvas, coordPtr, numPoints)
-    Tcl_Interp *interp;			/* Put generated Postscript in this
-					 * interpreter's result field. */
-    Tk_Canvas canvas;			/* Canvas on whose behalf Postscript
-					 * is being generated. */
-    double *coordPtr;			/* Pointer to first in array of
-					 * 2*numPoints coordinates giving
-					 * points for path. */
-    int numPoints;			/* Number of points at *coordPtr. */
+    Tcl_Interp *interp;		/* Put generated Postscript in this
+				 * interpreter's result field. */
+    Tk_Canvas canvas;		/* Canvas on whose behalf Postscript is being
+				 * generated. */
+    double *coordPtr;		/* Pointer to first in array of 2*numPoints
+				 * coordinates giving points for path. */
+    int numPoints;		/* Number of points at *coordPtr. */
 {
     Tk_PostscriptPath(interp, ((TkCanvas *) canvas)->psInfo,
 	    coordPtr, numPoints);
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */