Whitespace/style/ANSI improvements

8 files changed, 2785 insertions, 2876 deletions

diff --git a/unix/tkUnixColor.c b/unix/tkUnixColor.c
index 0337ee6..e32233b 100644
--- a/unix/tkUnixColor.c
+++ b/unix/tkUnixColor.c
@@ -1,54 +1,53 @@
-/* 
+/*
  * tkUnixColor.c --
  *
- *	This file contains the platform specific color routines
- *	needed for X support.
+ *	This file contains the platform specific color routines needed for X
+ *	support.
  *
  * Copyright (c) 1996 by Sun Microsystems, Inc.
  *
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkUnixColor.c,v 1.3 2004/01/13 02:06:01 davygrvy Exp $
+ * RCS: @(#) $Id: tkUnixColor.c,v 1.4 2005/10/21 01:51:44 dkf Exp $
  */
 
 #include <tkColor.h>
 
 /*
- * If a colormap fills up, attempts to allocate new colors from that
- * colormap will fail.  When that happens, we'll just choose the
- * closest color from those that are available in the colormap.
- * One of the following structures will be created for each "stressed"
- * colormap to keep track of the colors that are available in the
- * colormap (otherwise we would have to re-query from the server on
- * each allocation, which would be very slow).  These entries are
- * flushed after a few seconds, since other clients may release or
+ * If a colormap fills up, attempts to allocate new colors from that colormap
+ * will fail. When that happens, we'll just choose the closest color from
+ * those that are available in the colormap. One of the following structures
+ * will be created for each "stressed" colormap to keep track of the colors
+ * that are available in the colormap (otherwise we would have to re-query
+ * from the server on each allocation, which would be very slow). These
+ * entries are flushed after a few seconds, since other clients may release or
  * reallocate colors over time.
  */
 
 struct TkStressedCmap {
-    Colormap colormap;			/* X's token for the colormap. */
-    int numColors;			/* Number of entries currently active
-					 * at *colorPtr. */
-    XColor *colorPtr;			/* Pointer to malloc'ed array of all
-					 * colors that seem to be available in
-					 * the colormap.  Some may not actually
-					 * be available, e.g. because they are
-					 * read-write for another client;  when
-					 * we find this out, we remove them
-					 * from the array. */
-    struct TkStressedCmap *nextPtr;	/* Next in list of all stressed
-					 * colormaps for the display. */
+    Colormap colormap;		/* X's token for the colormap. */
+    int numColors;		/* Number of entries currently active at
+				 * *colorPtr. */
+    XColor *colorPtr;		/* Pointer to malloc'ed array of all colors
+				 * that seem to be available in the colormap.
+				 * Some may not actually be available, e.g.
+				 * because they are read-write for another
+				 * client; when we find this out, we remove
+				 * them from the array. */
+    struct TkStressedCmap *nextPtr;
+				/* Next in list of all stressed colormaps for
+				 * the display. */
 };
 
 /*
- * Forward declarations for procedures defined in this file:
+ * Forward declarations for functions defined in this file:
  */
 
-static void		DeleteStressedCmap _ANSI_ARGS_((Display *display,
-			    Colormap colormap));
-static void		FindClosestColor _ANSI_ARGS_((Tk_Window tkwin,
-			    XColor *desiredColorPtr, XColor *actualColorPtr));
+static void		DeleteStressedCmap(Display *display,
+			    Colormap colormap);
+static void		FindClosestColor(Tk_Window tkwin,
+			    XColor *desiredColorPtr, XColor *actualColorPtr);
 
 /*
  *----------------------------------------------------------------------
@@ -61,15 +60,15 @@ static void		FindClosestColor _ANSI_ARGS_((Tk_Window tkwin,
  *	None
  *
  * Side effects:
- *	Invalidates the colormap cache for the colormap associated with
- *	the given color.
+ *	Invalidates the colormap cache for the colormap associated with the
+ *	given color.
  *
  *----------------------------------------------------------------------
  */
 
 void
-TkpFreeColor(tkColPtr)
-    TkColor *tkColPtr;		/* Color to be released.  Must have been
+TkpFreeColor(
+    TkColor *tkColPtr)		/* Color to be released. Must have been
 				 * allocated by TkpGetColor or
 				 * TkpGetColorByValue. */
 {
@@ -77,14 +76,13 @@ TkpFreeColor(tkColPtr)
     Screen *screen = tkColPtr->screen;
 
     /*
-     * Careful!  Don't free black or white, since this will
-     * make some servers very unhappy.  Also, there is a bug in
-     * some servers (such Sun's X11/NeWS server) where reference
-     * counting is performed incorrectly, so that if a color is
-     * allocated twice in different places and then freed twice,
-     * the second free generates an error (this bug existed as of
-     * 10/1/92).  To get around this problem, ignore errors that
-     * occur during the free operation.
+     * Careful! Don't free black or white, since this will make some servers
+     * very unhappy. Also, there is a bug in some servers (such Sun's X11/NeWS
+     * server) where reference counting is performed incorrectly, so that if a
+     * color is allocated twice in different places and then freed twice, the
+     * second free generates an error (this bug existed as of 10/1/92). To get
+     * around this problem, ignore errors that occur during the free
+     * operation.
      */
 
     visual = tkColPtr->visual;
@@ -94,7 +92,7 @@ TkpFreeColor(tkColPtr)
 	Tk_ErrorHandler handler;
 
 	handler = Tk_CreateErrorHandler(DisplayOfScreen(screen),
-		-1, -1, -1, (Tk_ErrorProc *) NULL, (ClientData) NULL);
+		-1, -1, -1, NULL, NULL);
 	XFreeColors(DisplayOfScreen(screen), tkColPtr->colormap,
 		&tkColPtr->color.pixel, 1, 0L);
 	Tk_DeleteErrorHandler(handler);
@@ -114,16 +112,15 @@ TkpFreeColor(tkColPtr)
  *
  * Side effects:
  *	May invalidate the colormap cache associated with tkwin upon
- *	allocating a new colormap entry.  Allocates a new TkColor
- *	structure.
+ *	allocating a new colormap entry. Allocates a new TkColor structure.
  *
  *----------------------------------------------------------------------
  */
 
 TkColor *
-TkpGetColor(tkwin, name)
-    Tk_Window tkwin;		/* Window in which color will be used. */
-    Tk_Uid name;		/* Name of color to allocated (in form
+TkpGetColor(
+    Tk_Window tkwin,		/* Window in which color will be used. */
+    Tk_Uid name)		/* Name of color to allocated (in form
 				 * suitable for passing to XParseColor). */
 {
     Display *display = Tk_Display(tkwin);
@@ -132,7 +129,7 @@ TkpGetColor(tkwin, name)
     TkColor *tkColPtr;
 
     /*
-     * Map from the name to a pixel value.  Call XAllocNamedColor rather than
+     * Map from the name to a pixel value. Call XAllocNamedColor rather than
      * XParseColor for non-# names: this saves a server round-trip for those
      * names.
      */
@@ -145,21 +142,20 @@ TkpGetColor(tkwin, name)
 	    DeleteStressedCmap(display, colormap);
 	} else {
 	    /*
-	     * Couldn't allocate the color.  Try translating the name to
-	     * a color value, to see whether the problem is a bad color
-	     * name or a full colormap.  If the colormap is full, then
-	     * pick an approximation to the desired color.
+	     * Couldn't allocate the color. Try translating the name to a
+	     * color value, to see whether the problem is a bad color name or
+	     * a full colormap. If the colormap is full, then pick an
+	     * approximation to the desired color.
 	     */
 
-	    if (XLookupColor(display, colormap, name, &color,
-		    &screen) == 0) {
-		return (TkColor *) NULL;
+	    if (XLookupColor(display, colormap, name, &color, &screen) == 0) {
+		return NULL;
 	    }
 	    FindClosestColor(tkwin, &screen, &color);
 	}
     } else {
 	if (XParseColor(display, colormap, name, &color) == 0) {
-	    return (TkColor *) NULL;
+	    return NULL;
 	}
 	if (XAllocColor(display, colormap, &color) != 0) {
 	    DeleteStressedCmap(display, colormap);
@@ -179,27 +175,26 @@ TkpGetColor(tkwin, name)
  *
  * TkpGetColorByValue --
  *
- *	Given a desired set of red-green-blue intensities for a color,
- *	locate a pixel value to use to draw that color in a given
- *	window.
+ *	Given a desired set of red-green-blue intensities for a color, locate
+ *	a pixel value to use to draw that color in a given window.
  *
  * Results:
- *	The return value is a pointer to an TkColor structure that
- *	indicates the closest red, blue, and green intensities available
- *	to those specified in colorPtr, and also specifies a pixel
- *	value to use to draw in that color.
+ *	The return value is a pointer to an TkColor structure that indicates
+ *	the closest red, blue, and green intensities available to those
+ *	specified in colorPtr, and also specifies a pixel value to use to draw
+ *	in that color.
  *
  * Side effects:
- *	May invalidate the colormap cache for the specified window.
- *	Allocates a new TkColor structure.
+ *	May invalidate the colormap cache for the specified window. Allocates
+ *	a new TkColor structure.
  *
  *----------------------------------------------------------------------
  */
 
 TkColor *
-TkpGetColorByValue(tkwin, colorPtr)
-    Tk_Window tkwin;		/* Window in which color will be used. */
-    XColor *colorPtr;		/* Red, green, and blue fields indicate
+TkpGetColorByValue(
+    Tk_Window tkwin,		/* Window in which color will be used. */
+    XColor *colorPtr)		/* Red, green, and blue fields indicate
 				 * desired color. */
 {
     Display *display = Tk_Display(tkwin);
@@ -223,15 +218,15 @@ TkpGetColorByValue(tkwin, colorPtr)
  *
  * FindClosestColor --
  *
- *	When Tk can't allocate a color because a colormap has filled
- *	up, this procedure is called to find and allocate the closest
- *	available color in the colormap.
+ *	When Tk can't allocate a color because a colormap has filled up, this
+ *	function is called to find and allocate the closest available color in
+ *	the colormap.
  *
  * Results:
- *	There is no return value, but *actualColorPtr is filled in
- *	with information about the closest available color in tkwin's
- *	colormap.  This color has been allocated via X, so it must
- *	be released by the caller when the caller is done with it.
+ *	There is no return value, but *actualColorPtr is filled in with
+ *	information about the closest available color in tkwin's colormap.
+ *	This color has been allocated via X, so it must be released by the
+ *	caller when the caller is done with it.
  *
  * Side effects:
  *	A color is allocated.
@@ -240,13 +235,12 @@ TkpGetColorByValue(tkwin, colorPtr)
  */
 
 static void
-FindClosestColor(tkwin, desiredColorPtr, actualColorPtr)
-    Tk_Window tkwin;			/* Window where color will be used. */
-    XColor *desiredColorPtr;		/* RGB values of color that was
-					 * wanted (but unavailable). */
-    XColor *actualColorPtr;		/* Structure to fill in with RGB and
-					 * pixel for closest available
-					 * color. */
+FindClosestColor(
+    Tk_Window tkwin,		/* Window where color will be used. */
+    XColor *desiredColorPtr,	/* RGB values of color that was wanted (but
+				 * unavailable). */
+    XColor *actualColorPtr)	/* Structure to fill in with RGB and pixel for
+				 * closest available color. */
 {
     TkStressedCmap *stressPtr;
     double tmp, distance, closestDistance;
@@ -257,8 +251,8 @@ FindClosestColor(tkwin, desiredColorPtr, actualColorPtr)
     XVisualInfo template, *visInfoPtr;
 
     /*
-     * Find the TkStressedCmap structure for this colormap, or create
-     * a new one if needed.
+     * Find the TkStressedCmap structure for this colormap, or create a new
+     * one if needed.
      */
 
     for (stressPtr = dispPtr->stressPtr; ; stressPtr = stressPtr->nextPtr) {
@@ -266,20 +260,24 @@ FindClosestColor(tkwin, desiredColorPtr, actualColorPtr)
 	    stressPtr = (TkStressedCmap *) ckalloc(sizeof(TkStressedCmap));
 	    stressPtr->colormap = colormap;
 	    template.visualid = XVisualIDFromVisual(Tk_Visual(tkwin));
+
 	    visInfoPtr = XGetVisualInfo(Tk_Display(tkwin),
 		    VisualIDMask, &template, &numFound);
 	    if (numFound < 1) {
 		Tcl_Panic("FindClosestColor couldn't lookup visual");
 	    }
+
 	    stressPtr->numColors = visInfoPtr->colormap_size;
 	    XFree((char *) visInfoPtr);
 	    stressPtr->colorPtr = (XColor *) ckalloc((unsigned)
 		    (stressPtr->numColors * sizeof(XColor)));
-	    for (i = 0; i  < stressPtr->numColors; i++) {
+	    for (i = 0; i < stressPtr->numColors; i++) {
 		stressPtr->colorPtr[i].pixel = (unsigned long) i;
 	    }
+
 	    XQueryColors(dispPtr->display, colormap, stressPtr->colorPtr,
 		    stressPtr->numColors);
+
 	    stressPtr->nextPtr = dispPtr->stressPtr;
 	    dispPtr->stressPtr = stressPtr;
 	    break;
@@ -290,14 +288,14 @@ FindClosestColor(tkwin, desiredColorPtr, actualColorPtr)
     }
 
     /*
-     * Find the color that best approximates the desired one, then
-     * try to allocate that color.  If that fails, it must mean that
-     * the color was read-write (so we can't use it, since it's owner
-     * might change it) or else it was already freed.  Try again,
-     * over and over again, until something succeeds.
+     * Find the color that best approximates the desired one, then try to
+     * allocate that color. If that fails, it must mean that the color was
+     * read-write (so we can't use it, since it's owner might change it) or
+     * else it was already freed. Try again, over and over again, until
+     * something succeeds.
      */
 
-    while (1)  {
+    while (1) {
 	if (stressPtr->numColors == 0) {
 	    Tcl_Panic("FindClosestColor ran out of colors");
 	}
@@ -306,11 +304,11 @@ FindClosestColor(tkwin, desiredColorPtr, actualColorPtr)
 	for (colorPtr = stressPtr->colorPtr, i = 0; i < stressPtr->numColors;
 		colorPtr++, i++) {
 	    /*
-	     * Use Euclidean distance in RGB space, weighted by Y (of YIQ)
-	     * as the objective function;  this accounts for differences
-	     * in the color sensitivity of the eye.
+	     * Use Euclidean distance in RGB space, weighted by Y (of YIQ) as
+	     * the objective function; this accounts for differences in the
+	     * color sensitivity of the eye.
 	     */
-    
+
 	    tmp = .30*(((int) desiredColorPtr->red) - (int) colorPtr->red);
 	    distance = tmp*tmp;
 	    tmp = .61*(((int) desiredColorPtr->green) - (int) colorPtr->green);
@@ -329,8 +327,8 @@ FindClosestColor(tkwin, desiredColorPtr, actualColorPtr)
 	}
 
 	/*
-	 * Couldn't allocate the color.  Remove it from the table and
-	 * go back to look for the next best color.
+	 * Couldn't allocate the color. Remove it from the table and go back
+	 * to look for the next best color.
 	 */
 
 	stressPtr->colorPtr[closest] =
@@ -344,31 +342,30 @@ FindClosestColor(tkwin, desiredColorPtr, actualColorPtr)
  *
  * DeleteStressedCmap --
  *
- *	This procedure releases the information cached for "colormap"
- *	so that it will be refetched from the X server the next time
- *	it is needed.
+ *	This function releases the information cached for "colormap" so that
+ *	it will be refetched from the X server the next time it is needed.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The TkStressedCmap structure for colormap is deleted;  the
- *	colormap is no longer considered to be "stressed".
+ *	The TkStressedCmap structure for colormap is deleted; the colormap is
+ *	no longer considered to be "stressed".
  *
  * Note:
- *	This procedure is invoked whenever a color in a colormap is
- *	freed, and whenever a color allocation in a colormap succeeds.
- *	This guarantees that TkStressedCmap structures are always
- *	deleted before the corresponding Colormap is freed.
+ *	This function is invoked whenever a color in a colormap is freed, and
+ *	whenever a color allocation in a colormap succeeds. This guarantees
+ *	that TkStressedCmap structures are always deleted before the
+ *	corresponding Colormap is freed.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-DeleteStressedCmap(display, colormap)
-    Display *display;		/* Xlib's handle for the display
-				 * containing the colormap. */
-    Colormap colormap;		/* Colormap to flush. */
+DeleteStressedCmap(
+    Display *display,		/* Xlib's handle for the display containing
+				 * the colormap. */
+    Colormap colormap)		/* Colormap to flush. */
 {
     TkStressedCmap *prevPtr, *stressPtr;
     TkDisplay *dispPtr = TkGetDisplay(display);
@@ -393,12 +390,11 @@ DeleteStressedCmap(display, colormap)
  *
  * TkpCmapStressed --
  *
- *	Check to see whether a given colormap is known to be out
- *	of entries.
+ *	Check to see whether a given colormap is known to be out of entries.
  *
  * Results:
- *	1 is returned if "colormap" is stressed (i.e. it has run out
- *	of entries recently), 0 otherwise.
+ *	1 is returned if "colormap" is stressed (i.e. it has run out of
+ *	entries recently), 0 otherwise.
  *
  * Side effects:
  *	None.
@@ -407,10 +403,10 @@ DeleteStressedCmap(display, colormap)
  */
 
 int
-TkpCmapStressed(tkwin, colormap)
-    Tk_Window tkwin;		/* Window that identifies the display
+TkpCmapStressed(
+    Tk_Window tkwin,		/* Window that identifies the display
 				 * containing the colormap. */
-    Colormap colormap;		/* Colormap to check for stress. */
+    Colormap colormap)		/* Colormap to check for stress. */
 {
     TkStressedCmap *stressPtr;
 
@@ -422,3 +418,11 @@ TkpCmapStressed(tkwin, colormap)
     }
     return 0;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tkUnixCursor.c b/unix/tkUnixCursor.c
index 3ac51c5..858025c 100644
--- a/unix/tkUnixCursor.c
+++ b/unix/tkUnixCursor.c
@@ -1,14 +1,14 @@
-/* 
+/*
  * tkUnixCursor.c --
  *
  *	This file contains X specific cursor manipulation routines.
  *
  * Copyright (c) 1995-1997 Sun Microsystems, Inc.
  *
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkUnixCursor.c,v 1.6 2002/08/05 04:30:40 dgp Exp $
+ * RCS: @(#) $Id: tkUnixCursor.c,v 1.7 2005/10/21 01:51:45 dkf Exp $
  */
 
 #include "tkPort.h"
@@ -16,26 +16,24 @@
 
 /*
  * The following data structure is a superset of the TkCursor structure
- * defined in tkCursor.c.  Each system specific cursor module will define
- * a different cursor structure.  All of these structures must have the
- * same header consisting of the fields in TkCursor.
+ * defined in tkCursor.c. Each system specific cursor module will define a
+ * different cursor structure. All of these structures must have the same
+ * header consisting of the fields in TkCursor.
  */
 
-
-
 typedef struct {
     TkCursor info;		/* Generic cursor info used by tkCursor.c */
     Display *display;		/* Display for which cursor is valid. */
 } TkUnixCursor;
 
 /*
- * The table below is used to map from the name of a cursor to its
- * index in the official cursor font:
+ * The table below is used to map from the name of a cursor to its index in
+ * the official cursor font:
  */
 
 static struct CursorName {
-    char		*name;
-    unsigned int	shape;
+    CONST char *name;
+    unsigned int shape;
 } cursorNames[] = {
     {"X_cursor",		XC_X_cursor},
     {"arrow",			XC_arrow},
@@ -124,19 +122,18 @@ static struct CursorName {
 #ifndef CURSORFONT
 #define CURSORFONT "cursor"
 #endif
-
 
 /*
  *----------------------------------------------------------------------
  *
  * TkGetCursorByName --
  *
- *	Retrieve a cursor by name.  Parse the cursor name into fields
- *	and create a cursor, either from the standard cursor font or
- *	from bitmap files.
+ *	Retrieve a cursor by name. Parse the cursor name into fields and
+ *	create a cursor, either from the standard cursor font or from bitmap
+ *	files.
  *
  * Results:
- *	Returns a new cursor, or NULL on errors.  
+ *	Returns a new cursor, or NULL on errors.
  *
  * Side effects:
  *	Allocates a new cursor.
@@ -145,11 +142,11 @@ static struct CursorName {
  */
 
 TkCursor *
-TkGetCursorByName(interp, tkwin, string)
-    Tcl_Interp *interp;		/* Interpreter to use for error reporting. */
-    Tk_Window tkwin;		/* Window in which cursor will be used. */
-    Tk_Uid string;		/* Description of cursor.  See manual entry
-				 * for details on legal syntax. */
+TkGetCursorByName(
+    Tcl_Interp *interp,		/* Interpreter to use for error reporting. */
+    Tk_Window tkwin,		/* Window in which cursor will be used. */
+    Tk_Uid string)		/* Description of cursor. See manual entry for
+				 * details on legal syntax. */
 {
     TkUnixCursor *cursorPtr = NULL;
     Cursor cursor = None;
@@ -172,11 +169,11 @@ TkGetCursorByName(interp, tkwin, string)
 	TkDisplay *dispPtr;
 
 	/*
-	 * The cursor is to come from the standard cursor font.  If one
-	 * arg, it is cursor name (use black and white for fg and bg).
-	 * If two args, they are name and fg color (ignore mask).  If
-	 * three args, they are name, fg, bg.  Some of the code below
-	 * is stolen from the XCreateFontCursor Xlib procedure.
+	 * The cursor is to come from the standard cursor font. If one arg, it
+	 * is cursor name (use black and white for fg and bg). If two args,
+	 * they are name and fg color (ignore mask). If three args, they are
+	 * name, fg, bg. Some of the code below is stolen from the
+	 * XCreateFontCursor Xlib function.
 	 */
 
 	if (argc > 3) {
@@ -196,22 +193,19 @@ TkGetCursorByName(interp, tkwin, string)
 	    fg.red = fg.green = fg.blue = 0;
 	    bg.red = bg.green = bg.blue = 65535;
 	} else {
-	    if (XParseColor(display, Tk_Colormap(tkwin), argv[1],
-		    &fg) == 0) {
+	    if (XParseColor(display, Tk_Colormap(tkwin), argv[1], &fg) == 0) {
 		Tcl_AppendResult(interp, "invalid color name \"", argv[1],
-			"\"", (char *) NULL);
+			"\"", NULL);
 		goto cleanup;
 	    }
 	    if (argc == 2) {
 		bg.red = bg.green = bg.blue = 0;
 		maskIndex = namePtr->shape;
-	    } else {
-		if (XParseColor(display, Tk_Colormap(tkwin), argv[2],
-			&bg) == 0) {
-		    Tcl_AppendResult(interp, "invalid color name \"", argv[2],
-			    "\"", (char *) NULL);
-		    goto cleanup;
-		}
+	    } else if (XParseColor(display, Tk_Colormap(tkwin), argv[2],
+		    &bg) == 0) {
+		Tcl_AppendResult(interp, "invalid color name \"", argv[2],
+			"\"", NULL);
+		goto cleanup;
 	    }
 	}
 	dispPtr = ((TkWindow *) tkwin)->dispPtr;
@@ -230,21 +224,21 @@ TkGetCursorByName(interp, tkwin, string)
 	int xHot, yHot, dummy1, dummy2;
 	XColor fg, bg;
 
-        /*
-         * Prevent file system access in safe interpreters.
-         */
+	/*
+	 * Prevent file system access in safe interpreters.
+	 */
+
+	if (Tcl_IsSafe(interp)) {
+	    Tcl_AppendResult(interp, "can't get cursor from a file in",
+		    " a safe interpreter", NULL);
+	    cursorPtr = NULL;
+	    goto cleanup;
+	}
 
-        if (Tcl_IsSafe(interp)) {
-            Tcl_AppendResult(interp, "can't get cursor from a file in",
-                    " a safe interpreter", (char *) NULL);
-            cursorPtr = NULL;
-            goto cleanup;
-        }
-        
 	/*
-	 * The cursor is to be created by reading bitmap files.  There
-	 * should be either two elements in the list (source, color) or
-	 * four (source mask fg bg).
+	 * The cursor is to be created by reading bitmap files. There should
+	 * be either two elements in the list (source, color) or four (source
+	 * mask fg bg).
 	 */
 
 	if ((argc != 2) && (argc != 4)) {
@@ -255,19 +249,18 @@ TkGetCursorByName(interp, tkwin, string)
 		(unsigned int *) &width, (unsigned int *) &height,
 		&source, &xHot, &yHot) != BitmapSuccess) {
 	    Tcl_AppendResult(interp, "cleanup reading bitmap file \"",
-		    &argv[0][1], "\"", (char *) NULL);
+		    &argv[0][1], "\"", NULL);
 	    goto cleanup;
 	}
 	if ((xHot < 0) || (yHot < 0) || (xHot >= width) || (yHot >= height)) {
 	    Tcl_AppendResult(interp, "bad hot spot in bitmap file \"",
-		    &argv[0][1], "\"", (char *) NULL);
+		    &argv[0][1], "\"", NULL);
 	    goto cleanup;
 	}
 	if (argc == 2) {
-	    if (XParseColor(display, Tk_Colormap(tkwin), argv[1],
-		    &fg) == 0) {
+	    if (XParseColor(display, Tk_Colormap(tkwin), argv[1], &fg) == 0) {
 		Tcl_AppendResult(interp, "invalid color name \"",
-			argv[1], "\"", (char *) NULL);
+			argv[1], "\"", NULL);
 		goto cleanup;
 	    }
 	    cursor = XCreatePixmapCursor(display, source, source,
@@ -278,7 +271,7 @@ TkGetCursorByName(interp, tkwin, string)
 		    (unsigned int *) &maskWidth, (unsigned int *) &maskHeight,
 		    &mask, &dummy1, &dummy2) != BitmapSuccess) {
 		Tcl_AppendResult(interp, "cleanup reading bitmap file \"",
-			argv[1], "\"", (char *) NULL);
+			argv[1], "\"", NULL);
 		goto cleanup;
 	    }
 	    if ((maskWidth != width) && (maskHeight != height)) {
@@ -290,13 +283,13 @@ TkGetCursorByName(interp, tkwin, string)
 	    if (XParseColor(display, Tk_Colormap(tkwin), argv[2],
 		    &fg) == 0) {
 		Tcl_AppendResult(interp, "invalid color name \"", argv[2],
-			"\"", (char *) NULL);
+			"\"", NULL);
 		goto cleanup;
 	    }
 	    if (XParseColor(display, Tk_Colormap(tkwin), argv[3],
 		    &bg) == 0) {
 		Tcl_AppendResult(interp, "invalid color name \"", argv[3],
-			"\"", (char *) NULL);
+			"\"", NULL);
 		goto cleanup;
 	    }
 	    cursor = XCreatePixmapCursor(display, source, mask,
@@ -310,7 +303,7 @@ TkGetCursorByName(interp, tkwin, string)
 	cursorPtr->display = display;
     }
 
-    cleanup:
+  cleanup:
     if (argv != NULL) {
 	ckfree((char *) argv);
     }
@@ -322,13 +315,11 @@ TkGetCursorByName(interp, tkwin, string)
     }
     return (TkCursor *) cursorPtr;
 
-
-    badString:
+  badString:
     if (argv) {
 	ckfree((char *) argv);
     }
-    Tcl_AppendResult(interp, "bad cursor spec \"", string, "\"",
-	    (char *) NULL);
+    Tcl_AppendResult(interp, "bad cursor spec \"", string, "\"", NULL);
     return NULL;
 }
 
@@ -349,15 +340,14 @@ TkGetCursorByName(interp, tkwin, string)
  */
 
 TkCursor *
-TkCreateCursorFromData(tkwin, source, mask, width, height, xHot, yHot,
-	fgColor, bgColor)
-    Tk_Window tkwin;		/* Window in which cursor will be used. */
-    CONST char *source;		/* Bitmap data for cursor shape. */
-    CONST char *mask;		/* Bitmap data for cursor mask. */
-    int width, height;		/* Dimensions of cursor. */
-    int xHot, yHot;		/* Location of hot-spot in cursor. */
-    XColor fgColor;		/* Foreground color for cursor. */
-    XColor bgColor;		/* Background color for cursor. */
+TkCreateCursorFromData(
+    Tk_Window tkwin,		/* Window in which cursor will be used. */
+    CONST char *source,		/* Bitmap data for cursor shape. */
+    CONST char *mask,		/* Bitmap data for cursor mask. */
+    int width, int height,	/* Dimensions of cursor. */
+    int xHot, int yHot,		/* Location of hot-spot in cursor. */
+    XColor fgColor,		/* Foreground color for cursor. */
+    XColor bgColor)		/* Background color for cursor. */
 {
     Cursor cursor;
     Pixmap sourcePixmap, maskPixmap;
@@ -367,7 +357,7 @@ TkCreateCursorFromData(tkwin, source, mask, width, height, xHot, yHot,
     sourcePixmap = XCreateBitmapFromData(display,
 	    RootWindowOfScreen(Tk_Screen(tkwin)), source, (unsigned) width,
 	    (unsigned) height);
-    maskPixmap = XCreateBitmapFromData(display, 
+    maskPixmap = XCreateBitmapFromData(display,
 	    RootWindowOfScreen(Tk_Screen(tkwin)), mask, (unsigned) width,
 	    (unsigned) height);
     cursor = XCreatePixmapCursor(display, sourcePixmap,
@@ -388,7 +378,7 @@ TkCreateCursorFromData(tkwin, source, mask, width, height, xHot, yHot,
  *
  * TkpFreeCursor --
  *
- *	This procedure is called to release a cursor allocated by
+ *	This function is called to release a cursor allocated by
  *	TkGetCursorByName.
  *
  * Results:
@@ -401,10 +391,19 @@ TkCreateCursorFromData(tkwin, source, mask, width, height, xHot, yHot,
  */
 
 void
-TkpFreeCursor(cursorPtr)
-    TkCursor *cursorPtr;
+TkpFreeCursor(
+    TkCursor *cursorPtr)
 {
     TkUnixCursor *unixCursorPtr = (TkUnixCursor *) cursorPtr;
+
     XFreeCursor(unixCursorPtr->display, (Cursor) unixCursorPtr->info.cursor);
     Tk_FreeXId(unixCursorPtr->display, (XID) unixCursorPtr->info.cursor);
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tkUnixFocus.c b/unix/tkUnixFocus.c
index 7093544..479ef61 100644
--- a/unix/tkUnixFocus.c
+++ b/unix/tkUnixFocus.c
@@ -1,15 +1,15 @@
-/* 
+/*
  * tkUnixFocus.c --
  *
- *	This file contains platform specific procedures that manage
- *	focus for Tk.
+ *	This file contains platform specific functions that manage focus for
+ *	Tk.
  *
  * Copyright (c) 1997 Sun Microsystems, Inc.
  *
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkUnixFocus.c,v 1.4 2004/01/13 02:06:01 davygrvy Exp $
+ * RCS: @(#) $Id: tkUnixFocus.c,v 1.5 2005/10/21 01:51:45 dkf Exp $
  */
 
 #include "tkInt.h"
@@ -22,46 +22,44 @@
  *
  * TkpChangeFocus --
  *
- *	This procedure is invoked to move the official X focus from
- *	one window to another.
+ *	This function is invoked to move the official X focus from one window
+ *	to another.
  *
  * Results:
- *	The return value is the serial number of the command that
- *	changed the focus.  It may be needed by the caller to filter
- *	out focus change events that were queued before the command.
- *	If the procedure doesn't actually change the focus then
- *	it returns 0.
+ *	The return value is the serial number of the command that changed the
+ *	focus. It may be needed by the caller to filter out focus change
+ *	events that were queued before the command. If the function doesn't
+ *	actually change the focus then it returns 0.
  *
  * Side effects:
- *	The official X focus window changes;  the application's focus
- *	window isn't changed by this procedure.
+ *	The official X focus window changes; the application's focus window
+ *	isn't changed by this function.
  *
  *----------------------------------------------------------------------
  */
 
 int
-TkpChangeFocus(winPtr, force)
-    TkWindow *winPtr;		/* Window that is to receive the X focus. */
-    int force;			/* Non-zero means claim the focus even
-				 * if it didn't originally belong to
-				 * topLevelPtr's application. */
+TkpChangeFocus(
+    TkWindow *winPtr,		/* Window that is to receive the X focus. */
+    int force)			/* Non-zero means claim the focus even if it
+				 * didn't originally belong to topLevelPtr's
+				 * application. */
 {
     TkDisplay *dispPtr = winPtr->dispPtr;
     Tk_ErrorHandler errHandler;
-    Window window, root, parent, *children; 
-    unsigned int numChildren, serial; 
+    Window window, root, parent, *children;
+    unsigned int numChildren, serial;
     TkWindow *winPtr2;
     int dummy;
 
     /*
-     * Don't set the X focus to a window that's marked
-     * override-redirect.  This is a hack to avoid problems with menus
-     * under olvwm: if we move the focus then the focus can get lost
-     * during keyboard traversal.  Fortunately, we don't really need to
-     * move the focus for menus: events will still find their way to the
-     * focus window, and menus aren't decorated anyway so the window
-     * manager doesn't need to hear about the focus change in order to
-     * redecorate the menu.
+     * Don't set the X focus to a window that's marked override-redirect.
+     * This is a hack to avoid problems with menus under olvwm: if we move
+     * the focus then the focus can get lost during keyboard traversal.
+     * Fortunately, we don't really need to move the focus for menus: events
+     * will still find their way to the focus window, and menus aren't
+     * decorated anyway so the window manager doesn't need to hear about the
+     * focus change in order to redecorate the menu.
      */
 
     serial = 0;
@@ -70,19 +68,19 @@ TkpChangeFocus(winPtr, force)
     }
 
     /*
-     * Check to make sure that the focus is still in one of the windows
-     * of this application or one of their descendants.  Furthermore,
-     * grab the server to make sure that the focus doesn't change in the
-     * middle of this operation.
+     * Check to make sure that the focus is still in one of the windows of
+     * this application or one of their descendants. Furthermore, grab the
+     * server to make sure that the focus doesn't change in the middle of this
+     * operation.
      */
 
     XGrabServer(dispPtr->display);
     if (!force) {
 	/*
-	 * Find the focus window, then see if it or one of its ancestors
-	 * is a window in our application (it's possible that the focus
-	 * window is in an embedded application, which may or may not be
-	 * in the same process.
+	 * Find the focus window, then see if it or one of its ancestors is a
+	 * window in our application (it's possible that the focus window is
+	 * in an embedded application, which may or may not be in the same
+	 * process.
 	 */
 
 	XGetInputFocus(dispPtr->display, &window, &dummy);
@@ -107,13 +105,12 @@ TkpChangeFocus(winPtr, force)
     }
 
     /*
-     * Tell X to change the focus.  Ignore errors that occur when changing
-     * the focus:  it is still possible that the window we're focussing
-     * to could have gotten unmapped, which will generate an error.
+     * Tell X to change the focus. Ignore errors that occur when changing the
+     * focus: it is still possible that the window we're focussing to could
+     * have gotten unmapped, which will generate an error.
      */
 
-    errHandler = Tk_CreateErrorHandler(dispPtr->display, -1, -1, -1,
-	    (Tk_ErrorProc *) NULL, (ClientData) NULL);
+    errHandler = Tk_CreateErrorHandler(dispPtr->display, -1,-1,-1, NULL,NULL);
     if (winPtr->window == None) {
 	Tcl_Panic("ChangeXFocus got null X window");
     }
@@ -122,27 +119,35 @@ TkpChangeFocus(winPtr, force)
     Tk_DeleteErrorHandler(errHandler);
 
     /*
-     * Remember the current serial number for the X server and issue
-     * a dummy server request.  This marks the position at which we
-     * changed the focus, so we can distinguish FocusIn and FocusOut
-     * events on either side of the mark.
+     * Remember the current serial number for the X server and issue a dummy
+     * server request. This marks the position at which we changed the focus,
+     * so we can distinguish FocusIn and FocusOut events on either side of the
+     * mark.
      */
 
     serial = NextRequest(winPtr->display);
     XNoOp(winPtr->display);
 
-    done:
+  done:
     XUngrabServer(dispPtr->display);
 
     /*
      * After ungrabbing the server, it's important to flush the output
-     * immediately so that the server sees the ungrab command.  Otherwise
-     * we might do something else that needs to communicate with the
-     * server (such as invoking a subprocess that needs to do I/O to
-     * the screen); if the ungrab command is still sitting in our
-     * output buffer, we could deadlock.
+     * immediately so that the server sees the ungrab command. Otherwise we
+     * might do something else that needs to communicate with the server (such
+     * as invoking a subprocess that needs to do I/O to the screen); if the
+     * ungrab command is still sitting in our output buffer, we could
+     * deadlock.
      */
 
     XFlush(dispPtr->display);
     return serial;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tkUnixKey.c b/unix/tkUnixKey.c
index 6be5584..615ec82 100644
--- a/unix/tkUnixKey.c
+++ b/unix/tkUnixKey.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * tkUnixKey.c --
  *
  *	This file contains routines for dealing with international keyboard
@@ -6,28 +6,27 @@
  *
  * Copyright (c) 1997 by Sun Microsystems, Inc.
  *
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkUnixKey.c,v 1.10 2002/06/17 20:09:01 hobbs Exp $
+ * RCS: @(#) $Id: tkUnixKey.c,v 1.11 2005/10/21 01:51:45 dkf Exp $
  */
 
 #include "tkInt.h"
 
 /*
- * Prototypes for local procedures defined in this file:
+ * Prototypes for local functions defined in this file:
  */
-
 
 /*
  *----------------------------------------------------------------------
  *
  * Tk_SetCaretPos --
  *
- *	This enables correct placement of the XIM caret.  This is called
- *	by widgets to indicate their cursor placement, and the caret
- *	location is used by TkpGetString to place the XIM caret.
- *	This is currently only used for over-the-spot XIM.
+ *	This enables correct placement of the XIM caret. This is called by
+ *	widgets to indicate their cursor placement, and the caret location is
+ *	used by TkpGetString to place the XIM caret. This is currently only
+ *	used for over-the-spot XIM.
  *
  * Results:
  *	None
@@ -39,11 +38,11 @@
  */
 
 void
-Tk_SetCaretPos(tkwin, x, y, height)
-    Tk_Window tkwin;
-    int	      x;
-    int	      y;
-    int	      height;
+Tk_SetCaretPos(
+    Tk_Window tkwin,
+    int x,
+    int y,
+    int height)
 {
     TkCaret *caretPtr = &(((TkWindow *) tkwin)->dispPtr->caret);
 
@@ -68,19 +67,19 @@ Tk_SetCaretPos(tkwin, x, y, height)
  *	Returns the UTF string.
  *
  * Side effects:
- *	Stores the input string in the specified Tcl_DString.  Modifies
- *	the internal input state.  This routine can only be called
- *	once for a given event.
+ *	Stores the input string in the specified Tcl_DString. Modifies the
+ *	internal input state. This routine can only be called once for a given
+ *	event.
  *
  *----------------------------------------------------------------------
  */
 
 char *
-TkpGetString(winPtr, eventPtr, dsPtr)
-    TkWindow *winPtr;		/* Window where event occurred:  needed to
-				 * get input context. */
-    XEvent *eventPtr;		/* X keyboard event. */
-    Tcl_DString *dsPtr;		/* Uninitialized or empty string to hold
+TkpGetString(
+    TkWindow *winPtr,		/* Window where event occurred: needed to get
+				 * input context. */
+    XEvent *eventPtr,		/* X keyboard event. */
+    Tcl_DString *dsPtr)		/* Uninitialized or empty string to hold
 				 * result. */
 {
     int len;
@@ -107,8 +106,8 @@ TkpGetString(winPtr, eventPtr, dsPtr)
 #endif
 
 	len = XmbLookupString(winPtr->inputContext, &eventPtr->xkey,
-		Tcl_DStringValue(&buf), Tcl_DStringLength(&buf),
-		(KeySym *) NULL, &status);
+		Tcl_DStringValue(&buf), Tcl_DStringLength(&buf), NULL,
+		&status);
 	/*
 	 * If the buffer wasn't big enough, grow the buffer and try again.
 	 */
@@ -116,7 +115,7 @@ TkpGetString(winPtr, eventPtr, dsPtr)
 	if (status == XBufferOverflow) {
 	    Tcl_DStringSetLength(&buf, len);
 	    len = XmbLookupString(winPtr->inputContext, &eventPtr->xkey,
-		    Tcl_DStringValue(&buf), len, (KeySym *) NULL, &status);
+		    Tcl_DStringValue(&buf), len, NULL, &status);
 	}
 	if ((status != XLookupChars) && (status != XLookupBoth)) {
 	    len = 0;
@@ -124,9 +123,10 @@ TkpGetString(winPtr, eventPtr, dsPtr)
 
 #if TK_XIM_SPOT
 	/*
-	 * Adjust the XIM caret position.  We might want to check that
-	 * this is the right caret.winPtr as well.
+	 * Adjust the XIM caret position. We might want to check that this is
+	 * the right caret.winPtr as well.
 	 */
+
 	if (dispPtr->flags & TK_DISPLAY_XIM_SPOT) {
 	    spot.x = dispPtr->caret.x;
 	    spot.y = dispPtr->caret.y + dispPtr->caret.height;
@@ -138,13 +138,11 @@ TkpGetString(winPtr, eventPtr, dsPtr)
 #endif
     } else {
 	len = XLookupString(&eventPtr->xkey, Tcl_DStringValue(&buf),
-		Tcl_DStringLength(&buf), (KeySym *) NULL,
-		(XComposeStatus *) NULL);
+		Tcl_DStringLength(&buf), NULL, NULL);
     }
 #else /* TK_USE_INPUT_METHODS */
     len = XLookupString(&eventPtr->xkey, Tcl_DStringValue(&buf),
-	    Tcl_DStringLength(&buf), (KeySym *) NULL,
-	    (XComposeStatus *) NULL);
+	    Tcl_DStringLength(&buf), NULL, NULL);
 #endif /* TK_USE_INPUT_METHODS */
     Tcl_DStringSetLength(&buf, len);
 
@@ -155,25 +153,23 @@ TkpGetString(winPtr, eventPtr, dsPtr)
 }
 
 /*
- * When mapping from a keysym to a keycode, need
- * information about the modifier state that should be used
- * so that when they call XKeycodeToKeysym taking into
- * account the xkey.state, they will get back the original
- * keysym.
+ * When mapping from a keysym to a keycode, need information about the
+ * modifier state that should be used so that when they call XKeycodeToKeysym
+ * taking into account the xkey.state, they will get back the original keysym.
  */
 
 void
-TkpSetKeycodeAndState(tkwin, keySym, eventPtr)
-    Tk_Window tkwin;
-    KeySym keySym;
-    XEvent *eventPtr;
+TkpSetKeycodeAndState(
+    Tk_Window tkwin,
+    KeySym keySym,
+    XEvent *eventPtr)
 {
     Display *display;
     int state;
     KeyCode keycode;
-    
+
     display = Tk_Display(tkwin);
-    
+
     if (keySym == NoSymbol) {
 	keycode = 0;
     } else {
@@ -203,26 +199,24 @@ TkpSetKeycodeAndState(tkwin, keySym, eventPtr)
  *
  * TkpGetKeySym --
  *
- *	Given an X KeyPress or KeyRelease event, map the
- *	keycode in the event into a KeySym.
+ *	Given an X KeyPress or KeyRelease event, map the keycode in the event
+ *	into a KeySym.
  *
  * Results:
- *	The return value is the KeySym corresponding to
- *	eventPtr, or NoSymbol if no matching Keysym could be
- *	found.
+ *	The return value is the KeySym corresponding to eventPtr, or NoSymbol
+ *	if no matching Keysym could be found.
  *
  * Side effects:
- *	In the first call for a given display, keycode-to-
- *	KeySym maps get loaded.
+ *	In the first call for a given display, keycode-to-KeySym maps get
+ *	loaded.
  *
  *----------------------------------------------------------------------
  */
 
 KeySym
-TkpGetKeySym(dispPtr, eventPtr)
-    TkDisplay *dispPtr;	/* Display in which to
-					 * map keycode. */
-    XEvent *eventPtr;		/* Description of X event. */
+TkpGetKeySym(
+    TkDisplay *dispPtr,		/* Display in which to map keycode. */
+    XEvent *eventPtr)		/* Description of X event. */
 {
     KeySym sym;
     int index;
@@ -236,9 +230,9 @@ TkpGetKeySym(dispPtr, eventPtr)
     }
 
     /*
-     * Figure out which of the four slots in the keymap vector to
-     * use for this key.  Refer to Xlib documentation for more info
-     * on how this computation works.
+     * Figure out which of the four slots in the keymap vector to use for this
+     * key. Refer to Xlib documentation for more info on how this computation
+     * works.
      */
 
     index = 0;
@@ -253,10 +247,9 @@ TkpGetKeySym(dispPtr, eventPtr)
     sym = XKeycodeToKeysym(dispPtr->display, eventPtr->xkey.keycode, index);
 
     /*
-     * Special handling:  if the key was shifted because of Lock, but
-     * lock is only caps lock, not shift lock, and the shifted keysym
-     * isn't upper-case alphabetic, then switch back to the unshifted
-     * keysym.
+     * Special handling: if the key was shifted because of Lock, but lock is
+     * only caps lock, not shift lock, and the shifted keysym isn't upper-case
+     * alphabetic, then switch back to the unshifted keysym.
      */
 
     if ((index & 1) && !(eventPtr->xkey.state & ShiftMask)
@@ -271,8 +264,8 @@ TkpGetKeySym(dispPtr, eventPtr)
     }
 
     /*
-     * Another bit of special handling:  if this is a shifted key and there
-     * is no keysym defined, then use the keysym for the unshifted key.
+     * Another bit of special handling: if this is a shifted key and there is
+     * no keysym defined, then use the keysym for the unshifted key.
      */
 
     if ((index & 1) && (sym == NoSymbol)) {
@@ -287,10 +280,9 @@ TkpGetKeySym(dispPtr, eventPtr)
  *
  * TkpInitKeymapInfo --
  *
- *	This procedure is invoked to scan keymap information
- *	to recompute stuff that's important for binding, such
- *	as the modifier key (if any) that corresponds to "mode
- *	switch".
+ *	This function is invoked to scan keymap information to recompute stuff
+ *	that's important for binding, such as the modifier key (if any) that
+ *	corresponds to "mode switch".
  *
  * Results:
  *	None.
@@ -302,8 +294,8 @@ TkpGetKeySym(dispPtr, eventPtr)
  */
 
 void
-TkpInitKeymapInfo(dispPtr)
-    TkDisplay *dispPtr;		/* Display for which to recompute keymap
+TkpInitKeymapInfo(
+    TkDisplay *dispPtr)		/* Display for which to recompute keymap
 				 * information. */
 {
     XModifierKeymap *modMapPtr;
@@ -316,9 +308,9 @@ TkpInitKeymapInfo(dispPtr)
     modMapPtr = XGetModifierMapping(dispPtr->display);
 
     /*
-     * Check the keycodes associated with the Lock modifier.  If
-     * any of them is associated with the XK_Shift_Lock modifier,
-     * then Lock has to be interpreted as Shift Lock, not Caps Lock.
+     * Check the keycodes associated with the Lock modifier. If any of them is
+     * associated with the XK_Shift_Lock modifier, then Lock has to be
+     * interpreted as Shift Lock, not Caps Lock.
      */
 
     dispPtr->lockUsage = LU_IGNORE;
@@ -339,9 +331,9 @@ TkpInitKeymapInfo(dispPtr)
     }
 
     /*
-     * Look through the keycodes associated with modifiers to see if
-     * the the "mode switch", "meta", or "alt" keysyms are associated
-     * with any modifiers.  If so, remember their modifier mask bits.
+     * Look through the keycodes associated with modifiers to see if the the
+     * "mode switch", "meta", or "alt" keysyms are associated with any
+     * modifiers. If so, remember their modifier mask bits.
      */
 
     dispPtr->modeModMask = 0;
@@ -411,3 +403,11 @@ TkpInitKeymapInfo(dispPtr)
     }
     XFreeModifiermap(modMapPtr);
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tkUnixSelect.c b/unix/tkUnixSelect.c
index a67e97d..4c94056 100644
--- a/unix/tkUnixSelect.c
+++ b/unix/tkUnixSelect.c
@@ -1,15 +1,14 @@
-/* 
+/*
  * tkUnixSelect.c --
  *
- *	This file contains X specific routines for manipulating 
- *	selections.
+ *	This file contains X specific routines for manipulating selections.
  *
  * Copyright (c) 1995-1997 Sun Microsystems, Inc.
  *
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkUnixSelect.c,v 1.13 2004/03/16 19:52:52 hobbs Exp $
+ * RCS: @(#) $Id: tkUnixSelect.c,v 1.14 2005/10/21 01:51:45 dkf Exp $
  */
 
 #include "tkInt.h"
@@ -20,7 +19,7 @@ typedef struct ConvertInfo {
 				 * for the next chunk; -1 means all data has
 				 * been transferred for this conversion. -2
 				 * means only the final zero-length transfer
-				 * still has to be done.  Otherwise it is the
+				 * still has to be done. Otherwise it is the
 				 * offset of the next chunk of data to
 				 * transfer. */
     Tcl_EncodingState state;	/* The encoding state needed across chunks. */
@@ -29,84 +28,79 @@ typedef struct ConvertInfo {
 } ConvertInfo;
 
 /*
- * When handling INCR-style selection retrievals, the selection owner
- * uses the following data structure to communicate between the
- * ConvertSelection procedure and TkSelPropProc.
+ * When handling INCR-style selection retrievals, the selection owner uses the
+ * following data structure to communicate between the ConvertSelection
+ * function and TkSelPropProc.
  */
 
 typedef struct IncrInfo {
     TkWindow *winPtr;		/* Window that owns selection. */
     Atom selection;		/* Selection that is being retrieved. */
-    Atom *multAtoms;		/* Information about conversions to
-				 * perform:  one or more pairs of
-				 * (target, property).  This either
-				 * points to a retrieved  property (for
-				 * MULTIPLE retrievals) or to a static
+    Atom *multAtoms;		/* Information about conversions to perform:
+				 * one or more pairs of (target, property).
+				 * This either points to a retrieved property
+				 * (for MULTIPLE retrievals) or to a static
 				 * array. */
     unsigned long numConversions;
-				/* Number of entries in converts (same as
-				 * # of pairs in multAtoms). */
-    ConvertInfo *converts;	/* One entry for each pair in multAtoms.
-				 * This array is malloc-ed. */
+				/* Number of entries in converts (same as # of
+				 * pairs in multAtoms). */
+    ConvertInfo *converts;	/* One entry for each pair in multAtoms. This
+				 * array is malloc-ed. */
     char **tempBufs;		/* One pointer for each pair in multAtoms;
 				 * each pointer is either NULL, or it points
 				 * to a small bit of character data that was
 				 * left over from the previous chunk. */
-    Tcl_EncodingState *state;	/* One state info per pair in multAtoms:
-				 * State info for encoding conversions
-				 * that span multiple buffers. */
+    Tcl_EncodingState *state;	/* One state info per pair in multAtoms: State
+				 * info for encoding conversions that span
+				 * multiple buffers. */
     int *flags;			/* One state flag per pair in multAtoms:
 				 * Encoding flags, set to TCL_ENCODING_START
 				 * at the beginning of an INCR transfer. */
-    int numIncrs;		/* Number of entries in converts that
-				 * aren't -1 (i.e. # of INCR-mode transfers
-				 * not yet completed). */
-    Tcl_TimerToken timeout;	/* Token for timer procedure. */
-    int idleTime;		/* Number of seconds since we heard
-				 * anything from the selection
-				 * requestor. */
+    int numIncrs;		/* Number of entries in converts that aren't
+				 * -1 (i.e. # of INCR-mode transfers not yet
+				 * completed). */
+    Tcl_TimerToken timeout;	/* Token for timer function. */
+    int idleTime;		/* Number of seconds since we heard anything
+				 * from the selection requestor. */
     Window reqWindow;		/* Requestor's window id. */
-    Time time;			/* Timestamp corresponding to
-				 * selection at beginning of request;
-				 * used to abort transfer if selection
-				 * changes. */
-    struct IncrInfo *nextPtr;	/* Next in list of all INCR-style
-				 * retrievals currently pending. */
+    Time time;			/* Timestamp corresponding to selection at
+				 * beginning of request; used to abort
+				 * transfer if selection changes. */
+    struct IncrInfo *nextPtr;	/* Next in list of all INCR-style retrievals
+				 * currently pending. */
 } IncrInfo;
 
-
 typedef struct ThreadSpecificData {
-    IncrInfo *pendingIncrs;     /* List of all incr structures
-				 * currently active. */
+    IncrInfo *pendingIncrs;	/* List of all incr structures currently
+				 * active. */
 } ThreadSpecificData;
 static Tcl_ThreadDataKey dataKey;
 
 /*
- * Largest property that we'll accept when sending or receiving the
- * selection:
+ * Largest property that we'll accept when sending or receiving the selection:
  */
 
 #define MAX_PROP_WORDS 100000
 
 static TkSelRetrievalInfo *pendingRetrievals = NULL;
-				/* List of all retrievals currently
-				 * being waited for. */
+				/* List of all retrievals currently being
+				 * waited for. */
 
 /*
- * Forward declarations for procedures defined in this file:
+ * Forward declarations for functions defined in this file:
  */
 
-static void		ConvertSelection _ANSI_ARGS_((TkWindow *winPtr,
-			    XSelectionRequestEvent *eventPtr));
-static void		IncrTimeoutProc _ANSI_ARGS_((ClientData clientData));
-static char *		SelCvtFromX _ANSI_ARGS_((long *propPtr, int numValues,
-			    Atom type, Tk_Window tkwin));
-static long *		SelCvtToX _ANSI_ARGS_((char *string, Atom type,
-			    Tk_Window tkwin, int *numLongsPtr));
-static int		SelectionSize _ANSI_ARGS_((TkSelHandler *selPtr));
-static void		SelRcvIncrProc _ANSI_ARGS_((ClientData clientData,
-			    XEvent *eventPtr));
-static void		SelTimeoutProc _ANSI_ARGS_((ClientData clientData));
+static void		ConvertSelection(TkWindow *winPtr,
+			    XSelectionRequestEvent *eventPtr);
+static void		IncrTimeoutProc(ClientData clientData);
+static char *		SelCvtFromX(long *propPtr, int numValues, Atom type,
+			    Tk_Window tkwin);
+static long *		SelCvtToX(char *string, Atom type, Tk_Window tkwin,
+			    int *numLongsPtr);
+static int		SelectionSize(TkSelHandler *selPtr);
+static void		SelRcvIncrProc(ClientData clientData,
+			    XEvent *eventPtr);
+static void		SelTimeoutProc(ClientData clientData);
 
 /*
  *----------------------------------------------------------------------
@@ -116,9 +110,9 @@ static void		SelTimeoutProc _ANSI_ARGS_((ClientData clientData));
  *	Retrieve the specified selection from another process.
  *
  * Results:
- *	The return value is a standard Tcl return value.
- *	If an error occurs (such as no selection exists)
- *	then an error message is left in the interp's result.
+ *	The return value is a standard Tcl return value. If an error occurs
+ *	(such as no selection exists) then an error message is left in the
+ *	interp's result.
  *
  * Side effects:
  *	None.
@@ -127,27 +121,26 @@ static void		SelTimeoutProc _ANSI_ARGS_((ClientData clientData));
  */
 
 int
-TkSelGetSelection(interp, tkwin, selection, target, proc, clientData)
-    Tcl_Interp *interp;		/* Interpreter to use for reporting
-				 * errors. */
-    Tk_Window tkwin;		/* Window on whose behalf to retrieve
-				 * the selection (determines display
-				 * from which to retrieve). */
-    Atom selection;		/* Selection to retrieve. */
-    Atom target;		/* Desired form in which selection
-				 * is to be returned. */
-    Tk_GetSelProc *proc;	/* Procedure to call to process the
-				 * selection, once it has been retrieved. */
-    ClientData clientData;	/* Arbitrary value to pass to proc. */
+TkSelGetSelection(
+    Tcl_Interp *interp,		/* Interpreter to use for reporting errors. */
+    Tk_Window tkwin,		/* Window on whose behalf to retrieve the
+				 * selection (determines display from which to
+				 * retrieve). */
+    Atom selection,		/* Selection to retrieve. */
+    Atom target,		/* Desired form in which selection is to be
+				 * returned. */
+    Tk_GetSelProc *proc,	/* Function to call to process the selection,
+				 * once it has been retrieved. */
+    ClientData clientData)	/* Arbitrary value to pass to proc. */
 {
     TkSelRetrievalInfo retr;
     TkWindow *winPtr = (TkWindow *) tkwin;
     TkDisplay *dispPtr = winPtr->dispPtr;
 
     /*
-     * The selection is owned by some other process.  To
-     * retrieve it, first record information about the retrieval
-     * in progress.  Use an internal window as the requestor.
+     * The selection is owned by some other process. To retrieve it, first
+     * record information about the retrieval in progress. Use an internal
+     * window as the requestor.
      */
 
     retr.interp = interp;
@@ -173,20 +166,20 @@ TkSelGetSelection(interp, tkwin, selection, target, proc, clientData)
     pendingRetrievals = &retr;
 
     /*
-     * Initiate the request for the selection.  Note:  can't use
-     * TkCurrentTime for the time.  If we do, and this application hasn't
-     * received any X events in a long time, the current time will be way
-     * in the past and could even predate the time when the selection was
-     * made;  if this happens, the request will be rejected.
+     * Initiate the request for the selection. Note: can't use TkCurrentTime
+     * for the time. If we do, and this application hasn't received any X
+     * events in a long time, the current time will be way in the past and
+     * could even predate the time when the selection was made; if this
+     * happens, the request will be rejected.
      */
 
     XConvertSelection(winPtr->display, retr.selection, retr.target,
 	    retr.property, retr.winPtr->window, CurrentTime);
 
     /*
-     * Enter a loop processing X events until the selection
-     * has been retrieved and processed.  If no response is
-     * received within a few seconds, then timeout.
+     * Enter a loop processing X events until the selection has been retrieved
+     * and processed. If no response is received within a few seconds, then
+     * timeout.
      */
 
     retr.timeout = Tcl_CreateTimerHandler(1000, SelTimeoutProc,
@@ -197,8 +190,7 @@ TkSelGetSelection(interp, tkwin, selection, target, proc, clientData)
     Tcl_DeleteTimerHandler(retr.timeout);
 
     /*
-     * Unregister the information about the selection retrieval
-     * in progress.
+     * Unregister the information about the selection retrieval in progress.
      */
 
     if (pendingRetrievals == &retr) {
@@ -223,20 +215,18 @@ TkSelGetSelection(interp, tkwin, selection, target, proc, clientData)
  *
  * TkSelPropProc --
  *
- *	This procedure is invoked when property-change events
- *	occur on windows not known to the toolkit.  Its function
- *	is to implement the sending side of the INCR selection
- *	retrieval protocol when the selection requestor deletes
- *	the property containing a part of the selection.
+ *	This function is invoked when property-change events occur on windows
+ *	not known to the toolkit. Its function is to implement the sending
+ *	side of the INCR selection retrieval protocol when the selection
+ *	requestor deletes the property containing a part of the selection.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	If the property that is receiving the selection was just
- *	deleted, then a new piece of the selection is fetched and
- *	placed in the property, until eventually there's no more
- *	selection to fetch.
+ *	If the property that is receiving the selection was just deleted, then
+ *	a new piece of the selection is fetched and placed in the property,
+ *	until eventually there's no more selection to fetch.
  *
  *----------------------------------------------------------------------
  */
@@ -253,13 +243,13 @@ TkSelPropProc(eventPtr)
     long buffer[TK_SEL_WORDS_AT_ONCE];
     TkDisplay *dispPtr = TkGetDisplay(eventPtr->xany.display);
     Tk_ErrorHandler errorHandler;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
-            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     /*
-     * See if this event announces the deletion of a property being
-     * used for an INCR transfer.  If so, then add the next chunk of
-     * data to the property.
+     * See if this event announces the deletion of a property being used for
+     * an INCR transfer. If so, then add the next chunk of data to the
+     * property.
      */
 
     if (eventPtr->xproperty.state != PropertyDelete) {
@@ -272,9 +262,9 @@ TkSelPropProc(eventPtr)
 	}
 
 	/*
-	 * For each conversion that has been requested, handle any
-	 * chunks that haven't been transmitted yet.
-	 */						  
+	 * For each conversion that has been requested, handle any chunks that
+	 * haven't been transmitted yet.
+	 */
 
 	for (i = 0; i < incrPtr->numConversions; i++) {
 	    if ((eventPtr->xproperty.atom != incrPtr->multAtoms[2*i + 1])
@@ -313,8 +303,8 @@ TkSelPropProc(eventPtr)
 	    formatType = selPtr->format;
 	    if (incrPtr->converts[i].offset == -2) {
 		/*
-		 * We already got the last chunk, so send a null chunk
-		 * to indicate that we are finished.
+		 * We already got the last chunk, so send a null chunk to
+		 * indicate that we are finished.
 		 */
 
 		numItems = 0;
@@ -326,15 +316,15 @@ TkSelPropProc(eventPtr)
 		TkSelSetInProgress(&ip);
 
 		/*
-		 * Copy any bytes left over from a partial character at the end
-		 * of the previous chunk into the beginning of the buffer.
+		 * Copy any bytes left over from a partial character at the
+		 * end of the previous chunk into the beginning of the buffer.
 		 * Pass the rest of the buffer space into the selection
 		 * handler.
 		 */
 
 		length = strlen(incrPtr->converts[i].buffer);
 		strcpy((char *)buffer, incrPtr->converts[i].buffer);
-			    
+
 		numItems = (*selPtr->proc)(selPtr->clientData,
 			incrPtr->converts[i].offset,
 			((char *) buffer) + length,
@@ -358,7 +348,8 @@ TkSelPropProc(eventPtr)
 	    ((char *) buffer)[numItems] = 0;
 
 	    errorHandler = Tk_CreateErrorHandler(eventPtr->xproperty.display,
-		    -1, -1, -1, (int (*)()) NULL, (ClientData) NULL);
+		    -1, -1, -1, (int (*)()) NULL, NULL);
+
 	    /*
 	     * Encode the data using the proper format for each type.
 	     */
@@ -404,8 +395,8 @@ TkSelPropProc(eventPtr)
 
 
 		/*
-		 * Now convert the data, growing the destination buffer
-		 * as needed. 
+		 * Now convert the data, growing the destination buffer as
+		 * needed.
 		 */
 
 		while (1) {
@@ -471,9 +462,9 @@ TkSelPropProc(eventPtr)
 	    Tk_DeleteErrorHandler(errorHandler);
 
 	    /*
-	     * Compute the next offset value.  If this was the last chunk,
-	     * then set the offset to -2.  If this was an empty chunk,
-	     * then set the offset to -1 to indicate we are done.
+	     * Compute the next offset value. If this was the last chunk, then
+	     * set the offset to -2. If this was an empty chunk, then set the
+	     * offset to -1 to indicate we are done.
 	     */
 
 	    if (numItems < TK_SEL_BYTES_AT_ONCE) {
@@ -485,10 +476,10 @@ TkSelPropProc(eventPtr)
 		}
 	    } else {
 		/*
-		 * Advance over the selection data that was consumed
-		 * this time.
+		 * Advance over the selection data that was consumed this
+		 * time.
 		 */
- 
+
 		incrPtr->converts[i].offset += numItems - length;
 	    }
 	    return;
@@ -501,26 +492,24 @@ TkSelPropProc(eventPtr)
  *
  * TkSelEventProc --
  *
- *	This procedure is invoked whenever a selection-related
- *	event occurs.  It does the lion's share of the work
- *	in implementing the selection protocol.
+ *	This function is invoked whenever a selection-related event occurs.
+ *	It does the lion's share of the work in implementing the selection
+ *	protocol.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Lots:  depends on the type of event.
+ *	Lots: depends on the type of event.
  *
  *--------------------------------------------------------------
  */
 
 void
-TkSelEventProc(tkwin, eventPtr)
-    Tk_Window tkwin;		/* Window for which event was
-				 * targeted. */
-    register XEvent *eventPtr;	/* X event:  either SelectionClear,
-				 * SelectionRequest, or
-				 * SelectionNotify. */
+TkSelEventProc(
+    Tk_Window tkwin,		/* Window for which event was targeted. */
+    register XEvent *eventPtr)	/* X event: either SelectionClear,
+				 * SelectionRequest, or SelectionNotify. */
 {
     register TkWindow *winPtr = (TkWindow *) tkwin;
     TkDisplay *dispPtr = winPtr->dispPtr;
@@ -535,8 +524,8 @@ TkSelEventProc(tkwin, eventPtr)
     }
 
     /*
-     * Case #2: SelectionNotify events.  Call the relevant procedure
-     * to handle the incoming selection.
+     * Case #2: SelectionNotify events. Call the relevant function to handle
+     * the incoming selection.
      */
 
     if (eventPtr->type == SelectionNotify) {
@@ -559,12 +548,12 @@ TkSelEventProc(tkwin, eventPtr)
 		    break;
 		}
 		if (eventPtr->xselection.property == None) {
-		    Tcl_SetResult(retrPtr->interp, (char *) NULL, TCL_STATIC);
+		    Tcl_SetResult(retrPtr->interp, NULL, TCL_STATIC);
 		    Tcl_AppendResult(retrPtr->interp,
 			    Tk_GetAtomName(tkwin, retrPtr->selection),
 			    " selection doesn't exist or form \"",
 			    Tk_GetAtomName(tkwin, retrPtr->target),
-			    "\" not defined", (char *) NULL);
+			    "\" not defined", NULL);
 		    retrPtr->result = TCL_ERROR;
 		    return;
 		}
@@ -593,25 +582,25 @@ TkSelEventProc(tkwin, eventPtr)
 	    if (format != 8) {
 		char buf[64 + TCL_INTEGER_SPACE];
 
-		sprintf(buf, 
+		sprintf(buf,
 			"bad format for string selection: wanted \"8\", got \"%d\"",
 			format);
 		Tcl_SetResult(retrPtr->interp, buf, TCL_VOLATILE);
 		retrPtr->result = TCL_ERROR;
 		return;
 	    }
-            interp = retrPtr->interp;
-            Tcl_Preserve((ClientData) interp);
+	    interp = retrPtr->interp;
+	    Tcl_Preserve((ClientData) interp);
 
 	    /*
-	     * Convert the X selection data into UTF before passing it
-	     * to the selection callback.  Note that the COMPOUND_TEXT
-	     * uses a modified iso2022 encoding, not the current system
-	     * encoding.  For now we'll just blindly apply the iso2022
-	     * encoding.  This is probably wrong, but it's a placeholder
-	     * until we figure out what we're really supposed to do.  For
-	     * STRING, we need to use Latin-1 instead.  Again, it's not
-	     * really the full iso8859-1 space, but this is close enough.
+	     * Convert the X selection data into UTF before passing it to the
+	     * selection callback. Note that the COMPOUND_TEXT uses a modified
+	     * iso2022 encoding, not the current system encoding. For now
+	     * we'll just blindly apply the iso2022 encoding. This is probably
+	     * wrong, but it's a placeholder until we figure out what we're
+	     * really supposed to do. For STRING, we need to use Latin-1
+	     * instead. Again, it's not really the full iso8859-1 space, but
+	     * this is close enough.
 	     */
 
 	    if (type == dispPtr->compoundTextAtom) {
@@ -630,16 +619,17 @@ TkSelEventProc(tkwin, eventPtr)
 	    Tcl_Release((ClientData) interp);
 	} else if (type == dispPtr->utf8Atom) {
 	    /*
-	     * The X selection data is in UTF-8 format already.
-	     * We can't guarantee that propInfo is NULL-terminated,
-	     * so we might have to copy the string.
+	     * The X selection data is in UTF-8 format already. We can't
+	     * guarantee that propInfo is NULL-terminated, so we might have to
+	     * copy the string.
 	     */
+
 	    char *propData = propInfo;
 
 	    if (format != 8) {
 		char buf[64 + TCL_INTEGER_SPACE];
 
-		sprintf(buf, 
+		sprintf(buf,
 			"bad format for string selection: wanted \"8\", got \"%d\"",
 			format);
 		Tcl_SetResult(retrPtr->interp, buf, TCL_VOLATILE);
@@ -657,13 +647,12 @@ TkSelEventProc(tkwin, eventPtr)
 	    if (propData != propInfo) {
 		ckfree((char *) propData);
 	    }
-	} else if (type == dispPtr->incrAtom) {
 
+	} else if (type == dispPtr->incrAtom) {
 	    /*
-	     * It's a !?#@!?!! INCR-style reception.  Arrange to receive
-	     * the selection in pieces, using the ICCCM protocol, then
-	     * hang around until either the selection is all here or a
-	     * timeout occurs.
+	     * It's a !?#@!?!! INCR-style reception. Arrange to receive the
+	     * selection in pieces, using the ICCCM protocol, then hang around
+	     * until either the selection is all here or a timeout occurs.
 	     */
 
 	    retrPtr->idleTime = 0;
@@ -682,7 +671,7 @@ TkSelEventProc(tkwin, eventPtr)
 	    if (format != 32) {
 		char buf[64 + TCL_INTEGER_SPACE];
 
-		sprintf(buf, 
+		sprintf(buf,
 			"bad format for selection: wanted \"32\", got \"%d\"",
 			format);
 		Tcl_SetResult(retrPtr->interp, buf, TCL_VOLATILE);
@@ -691,11 +680,11 @@ TkSelEventProc(tkwin, eventPtr)
 	    }
 	    string = SelCvtFromX((long *) propInfo, (int) numItems, type,
 		    (Tk_Window) winPtr);
-            interp = retrPtr->interp;
-            Tcl_Preserve((ClientData) interp);
+	    interp = retrPtr->interp;
+	    Tcl_Preserve((ClientData) interp);
 	    retrPtr->result = (*retrPtr->proc)(retrPtr->clientData,
 		    interp, string);
-            Tcl_Release((ClientData) interp);
+	    Tcl_Release((ClientData) interp);
 	    ckfree(string);
 	}
 	XFree(propInfo);
@@ -703,8 +692,8 @@ TkSelEventProc(tkwin, eventPtr)
     }
 
     /*
-     * Case #3: SelectionRequest events.  Call ConvertSelection to
-     * do the dirty work.
+     * Case #3: SelectionRequest events. Call ConvertSelection to do the dirty
+     * work.
      */
 
     if (eventPtr->type == SelectionRequest) {
@@ -718,32 +707,30 @@ TkSelEventProc(tkwin, eventPtr)
  *
  * SelTimeoutProc --
  *
- *	This procedure is invoked once every second while waiting for
- *	the selection to be returned.  After a while it gives up and
- *	aborts the selection retrieval.
+ *	This function is invoked once every second while waiting for the
+ *	selection to be returned. After a while it gives up and aborts the
+ *	selection retrieval.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	A new timer callback is created to call us again in another
- *	second, unless time has expired, in which case an error is
- *	recorded for the retrieval.
+ *	A new timer callback is created to call us again in another second,
+ *	unless time has expired, in which case an error is recorded for the
+ *	retrieval.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-SelTimeoutProc(clientData)
-    ClientData clientData;		/* Information about retrieval
-					 * in progress. */
+SelTimeoutProc(
+    ClientData clientData)	/* Information about retrieval in progress. */
 {
     register TkSelRetrievalInfo *retrPtr = (TkSelRetrievalInfo *) clientData;
 
     /*
-     * Make sure that the retrieval is still in progress.  Then
-     * see how long it's been since any sort of response was received
-     * from the other side.
+     * Make sure that the retrieval is still in progress. Then see how long
+     * it's been since any sort of response was received from the other side.
      */
 
     if (retrPtr->result != -1) {
@@ -751,10 +738,9 @@ SelTimeoutProc(clientData)
     }
     retrPtr->idleTime++;
     if (retrPtr->idleTime >= 5) {
-
 	/*
-	 * Use a careful procedure to store the error message, because
-	 * the result could already be partially filled in with a partial
+	 * Use a careful function to store the error message, because the
+	 * result could already be partially filled in with a partial
 	 * selection return.
 	 */
 
@@ -772,46 +758,46 @@ SelTimeoutProc(clientData)
  *
  * ConvertSelection --
  *
- *	This procedure is invoked to handle SelectionRequest events.
- *	It responds to the requests, obeying the ICCCM protocols.
+ *	This function is invoked to handle SelectionRequest events. It
+ *	responds to the requests, obeying the ICCCM protocols.
  *
  * Results:
  *	None.
  *
  * Side effects:
  *	Properties are created for the selection requestor, and a
- *	SelectionNotify event is generated for the selection
- *	requestor.  In the event of long selections, this procedure
- *	implements INCR-mode transfers, using the ICCCM protocol.
+ *	SelectionNotify event is generated for the selection requestor. In the
+ *	event of long selections, this function implements INCR-mode
+ *	transfers, using the ICCCM protocol.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-ConvertSelection(winPtr, eventPtr)
-    TkWindow *winPtr;			/* Window that received the
-					 * conversion request;  may not be
-					 * selection's current owner, be we
-					 * set it to the current owner. */
-    register XSelectionRequestEvent *eventPtr;
-					/* Event describing request. */
+ConvertSelection(
+    TkWindow *winPtr,		/* Window that received the conversion
+				 * request; may not be selection's current
+				 * owner, be we set it to the current
+				 * owner. */
+    register XSelectionRequestEvent *eventPtr)
+				/* Event describing request. */
 {
-    XSelectionEvent reply;		/* Used to notify requestor that
-					 * selection info is ready. */
-    int multiple;			/* Non-zero means a MULTIPLE request
-					 * is being handled. */
-    IncrInfo incr;			/* State of selection conversion. */
-    Atom singleInfo[2];			/* incr.multAtoms points here except
-					 * for multiple conversions. */
+    XSelectionEvent reply;	/* Used to notify requestor that selection
+				 * info is ready. */
+    int multiple;		/* Non-zero means a MULTIPLE request is being
+				 * handled. */
+    IncrInfo incr;		/* State of selection conversion. */
+    Atom singleInfo[2];		/* incr.multAtoms points here except for
+				 * multiple conversions. */
     unsigned long i;
     Tk_ErrorHandler errorHandler;
     TkSelectionInfo *infoPtr;
     TkSelInProgress ip;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
-            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     errorHandler = Tk_CreateErrorHandler(eventPtr->display, -1, -1,-1,
-	    (int (*)()) NULL, (ClientData) NULL);
+	    (int (*)()) NULL, NULL);
 
     /*
      * Initialize the reply event.
@@ -841,8 +827,8 @@ ConvertSelection(winPtr, eventPtr)
     winPtr = (TkWindow *) infoPtr->owner;
 
     /*
-     * Figure out which kind(s) of conversion to perform.  If handling
-     * a MULTIPLE conversion, then read the property describing which
+     * Figure out which kind(s) of conversion to perform. If handling a
+     * MULTIPLE conversion, then read the property describing which
      * conversions to perform.
      */
 
@@ -864,9 +850,8 @@ ConvertSelection(winPtr, eventPtr)
 	if (eventPtr->property == None) {
 	    goto refuse;
 	}
-	result = XGetWindowProperty(eventPtr->display,
-		eventPtr->requestor, eventPtr->property,
-		0, MAX_PROP_WORDS, False, XA_ATOM,
+	result = XGetWindowProperty(eventPtr->display, eventPtr->requestor,
+		eventPtr->property, 0, MAX_PROP_WORDS, False, XA_ATOM,
 		&type, &format, &incr.numConversions, &bytesAfter,
 		(unsigned char **) &incr.multAtoms);
 	if ((result != Success) || (bytesAfter != 0) || (format != 32)
@@ -880,10 +865,10 @@ ConvertSelection(winPtr, eventPtr)
     }
 
     /*
-     * Loop through all of the requested conversions, and either return
-     * the entire converted selection, if it can be returned in a single
-     * bunch, or return INCR information only (the actual selection will
-     * be returned below).
+     * Loop through all of the requested conversions, and either return the
+     * entire converted selection, if it can be returned in a single bunch, or
+     * return INCR information only (the actual selection will be returned
+     * below).
      */
 
     incr.converts = (ConvertInfo *) ckalloc((unsigned)
@@ -911,9 +896,9 @@ ConvertSelection(winPtr, eventPtr)
 
 	if (selPtr == NULL) {
 	    /*
-	     * Nobody seems to know about this kind of request.  If
-	     * it's of a sort that we can handle without any help, do
-	     * it.  Otherwise mark the request as an errror.
+	     * Nobody seems to know about this kind of request. If it's of a
+	     * sort that we can handle without any help, do it. Otherwise mark
+	     * the request as an errror.
 	     */
 
 	    numItems = TkSelDefaultSelection(infoPtr, target, (char *) buffer,
@@ -941,13 +926,13 @@ ConvertSelection(winPtr, eventPtr)
 	}
 
 	/*
-	 * Got the selection;  store it back on the requestor's property.
+	 * Got the selection; store it back on the requestor's property.
 	 */
 
 	if (numItems == TK_SEL_BYTES_AT_ONCE) {
 	    /*
-	     * Selection is too big to send at once;  start an
-	     * INCR-mode transfer.
+	     * Selection is too big to send at once; start an INCR-mode
+	     * transfer.
 	     */
 
 	    incr.numIncrs++;
@@ -966,8 +951,8 @@ ConvertSelection(winPtr, eventPtr)
 		    (unsigned char *) propPtr, numItems);
 	} else if (type == winPtr->dispPtr->utf8Atom) {
 	    /*
-	     * This matches selection requests of type UTF8_STRING,
-	     * which allows us to pass our utf-8 information untouched.
+	     * This matches selection requests of type UTF8_STRING, which
+	     * allows us to pass our utf-8 information untouched.
 	     */
 
 	    XChangeProperty(reply.display, reply.requestor,
@@ -979,20 +964,19 @@ ConvertSelection(winPtr, eventPtr)
 	    Tcl_Encoding encoding;
 
 	    /*
-	     * STRING is Latin-1, COMPOUND_TEXT is an iso2022 variant.
-	     * We need to convert the selection text into these external
-	     * forms before modifying the property.
+	     * STRING is Latin-1, COMPOUND_TEXT is an iso2022 variant. We need
+	     * to convert the selection text into these external forms before
+	     * modifying the property.
 	     */
 
 	    if (type == XA_STRING) {
 		encoding = Tcl_GetEncoding(NULL, "iso8859-1");
 	    } else {
 		encoding = Tcl_GetEncoding(NULL, "iso2022");
-	    } 
+	    }
 	    Tcl_UtfToExternalDString(encoding, (char*)buffer, -1, &ds);
-	    XChangeProperty(reply.display, reply.requestor,
-		    property, type, 8, PropModeReplace,
-		    (unsigned char *) Tcl_DStringValue(&ds),
+	    XChangeProperty(reply.display, reply.requestor, property, type, 8,
+		    PropModeReplace, (unsigned char *) Tcl_DStringValue(&ds),
 		    Tcl_DStringLength(&ds));
 	    if (encoding) {
 		Tcl_FreeEncoding(encoding);
@@ -1002,18 +986,17 @@ ConvertSelection(winPtr, eventPtr)
 	    propPtr = (char *) SelCvtToX((char *) buffer,
 		    type, (Tk_Window) winPtr, &numItems);
 	    format = 32;
-	    XChangeProperty(reply.display, reply.requestor,
-		    property, type, format, PropModeReplace,
-		    (unsigned char *) propPtr, numItems);
+	    XChangeProperty(reply.display, reply.requestor, property, type,
+		    format, PropModeReplace, (unsigned char *) propPtr,
+		    numItems);
 	    ckfree(propPtr);
 	}
     }
 
     /*
-     * Send an event back to the requestor to indicate that the
-     * first stage of conversion is complete (everything is done
-     * except for long conversions that have to be done in INCR
-     * mode).
+     * Send an event back to the requestor to indicate that the first stage of
+     * conversion is complete (everything is done except for long conversions
+     * that have to be done in INCR mode).
      */
 
     if (incr.numIncrs > 0) {
@@ -1032,10 +1015,9 @@ ConvertSelection(winPtr, eventPtr)
 		(unsigned char *) incr.multAtoms,
 		(int) incr.numConversions*2);
     } else {
-
 	/*
-	 * Not a MULTIPLE request.  The first property in "multAtoms"
-	 * got set to None if there was an error in conversion.
+	 * Not a MULTIPLE request. The first property in "multAtoms" got set
+	 * to None if there was an error in conversion.
 	 */
 
 	reply.property = incr.multAtoms[1];
@@ -1044,9 +1026,9 @@ ConvertSelection(winPtr, eventPtr)
     Tk_DeleteErrorHandler(errorHandler);
 
     /*
-     * Handle any remaining INCR-mode transfers.  This all happens
-     * in callbacks to TkSelPropProc, so just wait until the number
-     * of uncompleted INCR transfers drops to zero.
+     * Handle any remaining INCR-mode transfers. This all happens in callbacks
+     * to TkSelPropProc, so just wait until the number of uncompleted INCR
+     * transfers drops to zero.
      */
 
     if (incr.numIncrs > 0) {
@@ -1057,7 +1039,7 @@ ConvertSelection(winPtr, eventPtr)
 	}
 	Tcl_DeleteTimerHandler(incr.timeout);
 	errorHandler = Tk_CreateErrorHandler(winPtr->display,
-		-1, -1,-1, (int (*)()) NULL, (ClientData) NULL);
+		-1, -1,-1, (int (*)()) NULL, NULL);
 	XSelectInput(reply.display, reply.requestor, 0L);
 	Tk_DeleteErrorHandler(errorHandler);
 	if (tsdPtr->pendingIncrs == &incr) {
@@ -1074,7 +1056,7 @@ ConvertSelection(winPtr, eventPtr)
     }
 
     /*
-     * All done.  Cleanup and return.
+     * All done. Cleanup and return.
      */
 
     ckfree((char *) incr.converts);
@@ -1084,10 +1066,10 @@ ConvertSelection(winPtr, eventPtr)
     return;
 
     /*
-     * An error occurred.  Send back a refusal message.
+     * An error occurred. Send back a refusal message.
      */
 
-    refuse:
+  refuse:
     reply.property = None;
     XSendEvent(reply.display, reply.requestor, False, 0, (XEvent *) &reply);
     Tk_DeleteErrorHandler(errorHandler);
@@ -1099,27 +1081,25 @@ ConvertSelection(winPtr, eventPtr)
  *
  * SelRcvIncrProc --
  *
- *	This procedure handles the INCR protocol on the receiving
- *	side.  It is invoked in response to property changes on
- *	the requestor's window (which hopefully are because a new
- *	chunk of the selection arrived).
+ *	This function handles the INCR protocol on the receiving side. It is
+ *	invoked in response to property changes on the requestor's window
+ *	(which hopefully are because a new chunk of the selection arrived).
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	If a new piece of selection has arrived, a procedure is
- *	invoked to deal with that piece.  When the whole selection
- *	is here, a flag is left for the higher-level procedure that
- *	initiated the selection retrieval.
+ *	If a new piece of selection has arrived, a function is invoked to deal
+ *	with that piece. When the whole selection is here, a flag is left for
+ *	the higher-level function that initiated the selection retrieval.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-SelRcvIncrProc(clientData, eventPtr)
-    ClientData clientData;		/* Information about retrieval. */
-    register XEvent *eventPtr;		/* X PropertyChange event. */
+SelRcvIncrProc(
+    ClientData clientData,	/* Information about retrieval. */
+    register XEvent *eventPtr)	/* X PropertyChange event. */
 {
     register TkSelRetrievalInfo *retrPtr = (TkSelRetrievalInfo *) clientData;
     char *propInfo;
@@ -1158,16 +1138,16 @@ SelRcvIncrProc(clientData, eventPtr)
 
 	if (format != 8) {
 	    char buf[64 + TCL_INTEGER_SPACE];
-	    
-	    sprintf(buf, 
+
+	    sprintf(buf,
 		    "bad format for string selection: wanted \"8\", got \"%d\"",
 		    format);
 	    Tcl_SetResult(retrPtr->interp, buf, TCL_VOLATILE);
 	    retrPtr->result = TCL_ERROR;
 	    goto done;
 	}
-        interp = retrPtr->interp;
-        Tcl_Preserve((ClientData) interp);
+	interp = retrPtr->interp;
+	Tcl_Preserve((ClientData) interp);
 
 	if (type == retrPtr->winPtr->dispPtr->compoundTextAtom) {
 	    encoding = Tcl_GetEncoding(NULL, "iso2022");
@@ -1179,8 +1159,8 @@ SelRcvIncrProc(clientData, eventPtr)
 
 	/*
 	 * Check to see if there is any data left over from the previous
-	 * chunk.  If there is, copy the old data and the new data into
-	 * a new buffer.
+	 * chunk. If there is, copy the old data and the new data into a new
+	 * buffer.
 	 */
 
 	Tcl_DStringInit(&temp);
@@ -1204,10 +1184,10 @@ SelRcvIncrProc(clientData, eventPtr)
 	    src = propInfo;
 	    srcLen = numItems;
 	}
-	
+
 	/*
-	 * Set up the destination buffer so we can use as much space as
-	 * is available.
+	 * Set up the destination buffer so we can use as much space as is
+	 * available.
 	 */
 
 	dstPtr = &retrPtr->buf;
@@ -1241,11 +1221,11 @@ SelRcvIncrProc(clientData, eventPtr)
 
 	result = (*retrPtr->proc)(retrPtr->clientData, interp,
 		Tcl_DStringValue(dstPtr));
-        Tcl_Release((ClientData) interp);
+	Tcl_Release((ClientData) interp);
 
 	/*
-	 * Copy any unused data into the destination buffer so we can
-	 * pick it up next time around.
+	 * Copy any unused data into the destination buffer so we can pick it
+	 * up next time around.
 	 */
 
 	Tcl_DStringSetLength(dstPtr, 0);
@@ -1275,17 +1255,17 @@ SelRcvIncrProc(clientData, eventPtr)
 	}
 	string = SelCvtFromX((long *) propInfo, (int) numItems, type,
 		(Tk_Window) retrPtr->winPtr);
-        interp = retrPtr->interp;
-        Tcl_Preserve((ClientData) interp);
+	interp = retrPtr->interp;
+	Tcl_Preserve((ClientData) interp);
 	result = (*retrPtr->proc)(retrPtr->clientData, interp, string);
-        Tcl_Release((ClientData) interp);
+	Tcl_Release((ClientData) interp);
 	if (result != TCL_OK) {
 	    retrPtr->result = result;
 	}
 	ckfree(string);
     }
 
-    done:
+  done:
     XFree(propInfo);
     retrPtr->idleTime = 0;
 }
@@ -1295,25 +1275,24 @@ SelRcvIncrProc(clientData, eventPtr)
  *
  * SelectionSize --
  *
- *	This procedure is called when the selection is too large to
- *	send in a single buffer;  it computes the total length of
- *	the selection in bytes.
+ *	This function is called when the selection is too large to send in a
+ *	single buffer; it computes the total length of the selection in bytes.
  *
  * Results:
- *	The return value is the number of bytes in the selection
- *	given by selPtr.
+ *	The return value is the number of bytes in the selection given by
+ *	selPtr.
  *
  * Side effects:
- *	The selection is retrieved from its current owner (this is
- *	the only way to compute its size).
+ *	The selection is retrieved from its current owner (this is the only
+ *	way to compute its size).
  *
  *----------------------------------------------------------------------
  */
 
 static int
-SelectionSize(selPtr)
-    TkSelHandler *selPtr;	/* Information about how to retrieve
-				 * the selection whose size is wanted. */
+SelectionSize(
+    TkSelHandler *selPtr)	/* Information about how to retrieve the
+				 * selection whose size is wanted. */
 {
     char buffer[TK_SEL_BYTES_AT_ONCE+1];
     int size, chunkSize;
@@ -1323,15 +1302,17 @@ SelectionSize(selPtr)
     ip.selPtr = selPtr;
     ip.nextPtr = TkSelGetInProgress();
     TkSelSetInProgress(&ip);
+
     do {
-	chunkSize = (*selPtr->proc)(selPtr->clientData, size,
-			(char *) buffer, TK_SEL_BYTES_AT_ONCE);
+	chunkSize = (*selPtr->proc)(selPtr->clientData, size, (char *) buffer,
+		TK_SEL_BYTES_AT_ONCE);
 	if (ip.selPtr == NULL) {
 	    size = 0;
 	    break;
 	}
 	size += chunkSize;
     } while (chunkSize == TK_SEL_BYTES_AT_ONCE);
+
     TkSelSetInProgress(ip.nextPtr);
     return size;
 }
@@ -1341,26 +1322,26 @@ SelectionSize(selPtr)
  *
  * IncrTimeoutProc --
  *
- *	This procedure is invoked once a second while sending the
- *	selection to a requestor in INCR mode.  After a while it
- *	gives up and aborts the selection operation.
+ *	This function is invoked once a second while sending the selection to
+ *	a requestor in INCR mode. After a while it gives up and aborts the
+ *	selection operation.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	A new timeout gets registered so that this procedure gets
- *	called again in another second, unless too many seconds
- *	have elapsed, in which case incrPtr is marked as "all done".
+ *	A new timeout gets registered so that this function gets called again
+ *	in another second, unless too many seconds have elapsed, in which case
+ *	incrPtr is marked as "all done".
  *
  *----------------------------------------------------------------------
  */
 
 static void
-IncrTimeoutProc(clientData)
-    ClientData clientData;		/* Information about INCR-mode
-					 * selection retrieval for which
-					 * we are selection owner. */
+IncrTimeoutProc(
+    ClientData clientData)	/* Information about INCR-mode selection
+				 * retrieval for which we are selection
+				 * owner. */
 {
     register IncrInfo *incrPtr = (IncrInfo *) clientData;
 
@@ -1379,15 +1360,15 @@ IncrTimeoutProc(clientData)
  * SelCvtToX --
  *
  *	Given a selection represented as a string (the normal Tcl form),
- *	convert it to the ICCCM-mandated format for X, depending on
- *	the type argument.  This procedure and SelCvtFromX are inverses.
+ *	convert it to the ICCCM-mandated format for X, depending on the type
+ *	argument. This function and SelCvtFromX are inverses.
  *
  * Results:
- *	The return value is a malloc'ed buffer holding a value
- *	equivalent to "string", but formatted as for "type".  It is
- *	the caller's responsibility to free the string when done with
- *	it.  The word at *numLongsPtr is filled in with the number of
- *	32-bit words returned in the result.
+ *	The return value is a malloc'ed buffer holding a value equivalent to
+ *	"string", but formatted as for "type". It is the caller's
+ *	responsibility to free the string when done with it. The word at
+ *	*numLongsPtr is filled in with the number of 32-bit words returned in
+ *	the result.
  *
  * Side effects:
  *	None.
@@ -1396,14 +1377,14 @@ IncrTimeoutProc(clientData)
  */
 
 static long *
-SelCvtToX(string, type, tkwin, numLongsPtr)
-    char *string;		/* String representation of selection. */
-    Atom type;			/* Atom specifying the X format that is
-				 * desired for the selection.  Should not
-				 * be XA_STRING (if so, don't bother calling
-				 * this procedure at all). */
-    Tk_Window tkwin;		/* Window that governs atom conversion. */
-    int *numLongsPtr;		/* Number of 32-bit words contained in the
+SelCvtToX(
+    char *string,		/* String representation of selection. */
+    Atom type,			/* Atom specifying the X format that is
+				 * desired for the selection. Should not be
+				 * XA_STRING (if so, don't bother calling this
+				 * function at all). */
+    Tk_Window tkwin,		/* Window that governs atom conversion. */
+    int *numLongsPtr)		/* Number of 32-bit words contained in the
 				 * result. */
 {
     register char *p;
@@ -1414,13 +1395,12 @@ SelCvtToX(string, type, tkwin, numLongsPtr)
     char atomName[MAX_ATOM_NAME_LENGTH+1];
 
     /*
-     * The string is assumed to consist of fields separated by spaces.
-     * The property gets generated by converting each field to an
-     * integer number, in one of two ways:
-     * 1. If type is XA_ATOM, convert each field to its corresponding
-     *	  atom.
-     * 2. If type is anything else, convert each field from an ASCII number
-     *    to a 32-bit binary number.
+     * The string is assumed to consist of fields separated by spaces. The
+     * property gets generated by converting each field to an integer number,
+     * in one of two ways:
+     * 1. If type is XA_ATOM, convert each field to its corresponding atom.
+     * 2. If type is anything else, convert each field from an ASCII number to
+     *    a 32-bit binary number.
      */
 
     numFields = 1;
@@ -1471,15 +1451,14 @@ SelCvtToX(string, type, tkwin, numLongsPtr)
  *
  * SelCvtFromX --
  *
- *	Given an X property value, formatted as a collection of 32-bit
- *	values according to "type" and the ICCCM conventions, convert
- *	the value to a string suitable for manipulation by Tcl.  This
- *	procedure is the inverse of SelCvtToX.
+ *	Given an X property value, formatted as a collection of 32-bit values
+ *	according to "type" and the ICCCM conventions, convert the value to a
+ *	string suitable for manipulation by Tcl. This function is the inverse
+ *	of SelCvtToX.
  *
  * Results:
- *	The return value is the string equivalent of "property".  It is
- *	malloc-ed and should be freed by the caller when no longer
- *	needed.
+ *	The return value is the string equivalent of "property". It is
+ *	malloc-ed and should be freed by the caller when no longer needed.
  *
  * Side effects:
  *	None.
@@ -1488,23 +1467,23 @@ SelCvtToX(string, type, tkwin, numLongsPtr)
  */
 
 static char *
-SelCvtFromX(propPtr, numValues, type, tkwin)
-    register long *propPtr;	/* Property value from X. */
-    int numValues;		/* Number of 32-bit values in property. */
-    Atom type;			/* Type of property  Should not be
-				 * XA_STRING (if so, don't bother calling
-				 * this procedure at all). */
-    Tk_Window tkwin;		/* Window to use for atom conversion. */
+SelCvtFromX(
+    register long *propPtr,	/* Property value from X. */
+    int numValues,		/* Number of 32-bit values in property. */
+    Atom type,			/* Type of property Should not be XA_STRING
+				 * (if so, don't bother calling this function
+				 * at all). */
+    Tk_Window tkwin)		/* Window to use for atom conversion. */
 {
     char *result;
     int resultSpace, curSize, fieldSize;
     CONST char *atomName;
 
     /*
-     * Convert each long in the property to a string value, which is
-     * either the name of an atom (if type is XA_ATOM) or a hexadecimal
-     * string.  Make an initial guess about the size of the result, but
-     * be prepared to enlarge the result if necessary.
+     * Convert each long in the property to a string value, which is either
+     * the name of an atom (if type is XA_ATOM) or a hexadecimal string. Make
+     * an initial guess about the size of the result, but be prepared to
+     * enlarge the result if necessary.
      */
 
     resultSpace = 12*numValues+1;
@@ -1544,3 +1523,11 @@ SelCvtFromX(propPtr, numValues, type, tkwin)
     }
     return result;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tkUnixSend.c b/unix/tkUnixSend.c
index 024005c..1c1f6b2 100644
--- a/unix/tkUnixSend.c
+++ b/unix/tkUnixSend.c
@@ -1,280 +1,268 @@
-/* 
+/*
  * tkUnixSend.c --
  *
- *	This file provides procedures that implement the "send"
- *	command, allowing commands to be passed from interpreter
- *	to interpreter.
+ *	This file provides functions that implement the "send" command,
+ *	allowing commands to be passed from interpreter to interpreter.
  *
  * Copyright (c) 1989-1994 The Regents of the University of California.
  * Copyright (c) 1994-1996 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: tkUnixSend.c,v 1.12 2004/01/13 02:06:01 davygrvy Exp $
+ * RCS: @(#) $Id: tkUnixSend.c,v 1.13 2005/10/21 01:51:45 dkf Exp $
  */
 
 #include "tkPort.h"
 #include "tkInt.h"
 #include "tkUnixInt.h"
 
-/* 
+/*
  * The following structure is used to keep track of the interpreters
  * registered by this process.
  */
 
 typedef struct RegisteredInterp {
     char *name;			/* Interpreter's name (malloc-ed). */
-    Tcl_Interp *interp;		/* Interpreter associated with name.  NULL
+    Tcl_Interp *interp;		/* Interpreter associated with name. NULL
 				 * means that the application was unregistered
-				 * or deleted while a send was in progress
-				 * to it. */
-    TkDisplay *dispPtr;		/* Display for the application.  Needed
-				 * because we may need to unregister the
-				 * interpreter after its main window has
-				 * been deleted. */
+				 * or deleted while a send was in progress to
+				 * it. */
+    TkDisplay *dispPtr;		/* Display for the application. Needed because
+				 * we may need to unregister the interpreter
+				 * after its main window has been deleted. */
     struct RegisteredInterp *nextPtr;
-				/* Next in list of names associated
-				 * with interps in this process.
-				 * NULL means end of list. */
+				/* Next in list of names associated with
+				 * interps in this process. NULL means end of
+				 * list. */
 } RegisteredInterp;
 
 /*
- * A registry of all interpreters for a display is kept in a
- * property "InterpRegistry" on the root window of the display.
- * It is organized as a series of zero or more concatenated strings
- * (in no particular order), each of the form
+ * A registry of all interpreters for a display is kept in a property
+ * "InterpRegistry" on the root window of the display. It is organized as a
+ * series of zero or more concatenated strings (in no particular order), each
+ * of the form
  * 	window space name '\0'
- * where "window" is the hex id of the comm. window to use to talk
- * to an interpreter named "name".
+ * where "window" is the hex id of the comm. window to use to talk to an
+ * interpreter named "name".
  *
- * When the registry is being manipulated by an application (e.g. to
- * add or remove an entry), it is loaded into memory using a structure
- * of the following type:
+ * When the registry is being manipulated by an application (e.g. to add or
+ * remove an entry), it is loaded into memory using a structure of the
+ * following type:
  */
 
 typedef struct NameRegistry {
     TkDisplay *dispPtr;		/* Display from which the registry was
 				 * read. */
-    int locked;			/* Non-zero means that the display was
-				 * locked when the property was read in. */
-    int modified;		/* Non-zero means that the property has
-				 * been modified, so it needs to be written
-				 * out when the NameRegistry is closed. */
+    int locked;			/* Non-zero means that the display was locked
+				 * when the property was read in. */
+    int modified;		/* Non-zero means that the property has been
+				 * modified, so it needs to be written out
+				 * when the NameRegistry is closed. */
     unsigned long propLength;	/* Length of the property, in bytes. */
-    char *property;		/* The contents of the property, or NULL
-				 * if none.  See format description above;
-				 * this is *not* terminated by the first
-				 * null character.  Dynamically allocated. */
+    char *property;		/* The contents of the property, or NULL if
+				 * none. See format description above; this is
+				 * *not* terminated by the first null
+				 * character. Dynamically allocated. */
     int allocedByX;		/* Non-zero means must free property with
-				 * XFree;  zero means use ckfree. */
+				 * XFree; zero means use ckfree. */
 } NameRegistry;
 
 /*
- * When a result is being awaited from a sent command, one of
- * the following structures is present on a list of all outstanding
- * sent commands.  The information in the structure is used to
- * process the result when it arrives.  You're probably wondering
- * how there could ever be multiple outstanding sent commands.
- * This could happen if interpreters invoke each other recursively.
+ * When a result is being awaited from a sent command, one of the following
+ * structures is present on a list of all outstanding sent commands. The
+ * information in the structure is used to process the result when it arrives.
+ * You're probably wondering how there could ever be multiple outstanding sent
+ * commands. This could happen if interpreters invoke each other recursively.
  * It's unlikely, but possible.
  */
 
 typedef struct PendingCommand {
-    int serial;			/* Serial number expected in
-				 * result. */
+    int serial;			/* Serial number expected in result. */
     TkDisplay *dispPtr;		/* Display being used for communication. */
-    CONST char *target;		/* Name of interpreter command is
-				 * being sent to. */
+    CONST char *target;		/* Name of interpreter command is being sent
+				 * to. */
     Window commWindow;		/* Target's communication window. */
-    Tcl_Interp *interp;		/* Interpreter from which the send
-				 * was invoked. */
-    int code;			/* Tcl return code for command
-				 * will be stored here. */
-    char *result;		/* String result for command (malloc'ed),
-				 * or NULL. */
-    char *errorInfo;		/* Information for "errorInfo" variable,
-				 * or NULL (malloc'ed). */
-    char *errorCode;		/* Information for "errorCode" variable,
-				 * or NULL (malloc'ed). */
-    int gotResponse;		/* 1 means a response has been received,
-				 * 0 means the command is still outstanding. */
+    Tcl_Interp *interp;		/* Interpreter from which the send was
+				 * invoked. */
+    int code;			/* Tcl return code for command will be stored
+				 * here. */
+    char *result;		/* String result for command (malloc'ed), or
+				 * NULL. */
+    char *errorInfo;		/* Information for "errorInfo" variable, or
+				 * NULL (malloc'ed). */
+    char *errorCode;		/* Information for "errorCode" variable, or
+				 * NULL (malloc'ed). */
+    int gotResponse;		/* 1 means a response has been received, 0
+				 * means the command is still outstanding. */
     struct PendingCommand *nextPtr;
-				/* Next in list of all outstanding
-				 * commands.  NULL means end of
-				 * list. */
+				/* Next in list of all outstanding commands.
+				 * NULL means end of list. */
 } PendingCommand;
 
 typedef struct ThreadSpecificData {
-    PendingCommand *pendingCommands;				
-                                /* List of all commands currently
-				 * being waited for. */
+    PendingCommand *pendingCommands;
+				/* List of all commands currently being waited
+				 * for. */
     RegisteredInterp *interpListPtr;
-                                /* List of all interpreters registered
-				 * in the current process. */
+				/* List of all interpreters registered in the
+				 * current process. */
 } ThreadSpecificData;
 static Tcl_ThreadDataKey dataKey;
 
 /*
- * The information below is used for communication between processes
- * during "send" commands.  Each process keeps a private window, never
- * even mapped, with one property, "Comm".  When a command is sent to
- * an interpreter, the command is appended to the comm property of the
- * communication window associated with the interp's process.  Similarly,
- * when a result is returned from a sent command, it is also appended
- * to the comm property.
- *
- * Each command and each result takes the form of ASCII text.  For a
- * command, the text consists of a zero character followed by several
- * null-terminated ASCII strings.  The first string consists of the
- * single letter "c".  Subsequent strings have the form "option value"
- * where the following options are supported:
+ * The information below is used for communication between processes during
+ * "send" commands. Each process keeps a private window, never even mapped,
+ * with one property, "Comm". When a command is sent to an interpreter, the
+ * command is appended to the comm property of the communication window
+ * associated with the interp's process. Similarly, when a result is returned
+ * from a sent command, it is also appended to the comm property.
+ *
+ * Each command and each result takes the form of ASCII text. For a command,
+ * the text consists of a zero character followed by several null-terminated
+ * ASCII strings. The first string consists of the single letter "c".
+ * Subsequent strings have the form "option value" where the following options
+ * are supported:
  *
  * -r commWindow serial
  *
- *	This option means that a response should be sent to the window
- *	whose X identifier is "commWindow" (in hex), and the response should
- *	be identified with the serial number given by "serial" (in decimal).
- *	If this option isn't specified then the send is asynchronous and
- *	no response is sent.
+ *	This option means that a response should be sent to the window whose X
+ *	identifier is "commWindow" (in hex), and the response should be
+ *	identified with the serial number given by "serial" (in decimal). If
+ *	this option isn't specified then the send is asynchronous and no
+ *	response is sent.
  *
  * -n name
+ *
  *	"Name" gives the name of the application for which the command is
- *	intended.  This option must be present.
+ *	intended. This option must be present.
  *
  * -s script
  *
- *	"Script" is the script to be executed.  This option must be present.
+ *	"Script" is the script to be executed. This option must be present.
  *
- * The options may appear in any order.  The -n and -s options must be
- * present, but -r may be omitted for asynchronous RPCs.  For compatibility
- * with future releases that may add new features, there may be additional
- * options present;  as long as they start with a "-" character, they will
- * be ignored.
+ * The options may appear in any order. The -n and -s options must be present,
+ * but -r may be omitted for asynchronous RPCs. For compatibility with future
+ * releases that may add new features, there may be additional options
+ * present; as long as they start with a "-" character, they will be ignored.
  *
  * A result also consists of a zero character followed by several null-
- * terminated ASCII strings.  The first string consists of the single
- * letter "r".  Subsequent strings have the form "option value" where
- * the following options are supported:
+ * terminated ASCII strings. The first string consists of the single letter
+ * "r". Subsequent strings have the form "option value" where the following
+ * options are supported:
  *
  * -s serial
  *
- *	Identifies the command for which this is the result.  It is the
- *	same as the "serial" field from the -s option in the command.  This
- *	option must be present.
+ *	Identifies the command for which this is the result. It is the same as
+ *	the "serial" field from the -s option in the command. This option must
+ *	be present.
  *
  * -c code
  *
- *	"Code" is the completion code for the script, in decimal.  If the
- *	code is omitted it defaults to TCL_OK.
+ *	"Code" is the completion code for the script, in decimal. If the code
+ *	is omitted it defaults to TCL_OK.
  *
  * -r result
  *
- *	"Result" is the result string for the script, which may be either
- *	a result or an error message.  If this field is omitted then it
- *	defaults to an empty string.
+ *	"Result" is the result string for the script, which may be either a
+ *	result or an error message. If this field is omitted then it defaults
+ *	to an empty string.
  *
  * -i errorInfo
  *
  *	"ErrorInfo" gives a string with which to initialize the errorInfo
- *	variable.  This option may be omitted;  it is ignored unless the
+ *	variable. This option may be omitted; it is ignored unless the
  *	completion code is TCL_ERROR.
  *
  * -e errorCode
  *
  *	"ErrorCode" gives a string with with to initialize the errorCode
- *	variable.  This option may be omitted;  it is ignored  unless the
+ *	variable. This option may be omitted; it is ignored unless the
  *	completion code is TCL_ERROR.
  *
- * Options may appear in any order, and only the -s option must be
- * present.  As with commands, there may be additional options besides
- * these;  unknown options are ignored.
+ * Options may appear in any order, and only the -s option must be present.
+ * As with commands, there may be additional options besides these; unknown
+ * options are ignored.
  */
 
 /*
- * The following variable is the serial number that was used in the
- * last "send" command.  It is exported only for testing purposes.
+ * The following variable is the serial number that was used in the last
+ * "send" command. It is exported only for testing purposes.
  */
 
 int tkSendSerial = 0;
 
 /*
- * Maximum size property that can be read at one time by
- * this module:
+ * Maximum size property that can be read at one time by this module:
  */
 
 #define MAX_PROP_WORDS 100000
 
 /*
- * The following variable can be set while debugging to do things like
- * skip locking the server.
+ * The following variable can be set while debugging to do things like skip
+ * locking the server.
  */
 
 static int sendDebug = 0;
 
 /*
- * Forward declarations for procedures defined later in this file:
+ * Forward declarations for functions defined later in this file:
  */
 
-static int		AppendErrorProc _ANSI_ARGS_((ClientData clientData,
-				XErrorEvent *errorPtr));
-static void		AppendPropCarefully _ANSI_ARGS_((Display *display,
+static int		AppendErrorProc(ClientData clientData,
+			    XErrorEvent *errorPtr);
+static void		AppendPropCarefully(Display *display,
 			    Window window, Atom property, char *value,
-			    int length, PendingCommand *pendingPtr));
-static void		DeleteProc _ANSI_ARGS_((ClientData clientData));
-static void		RegAddName _ANSI_ARGS_((NameRegistry *regPtr,
-			    CONST char *name, Window commWindow));
-static void		RegClose _ANSI_ARGS_((NameRegistry *regPtr));
-static void		RegDeleteName _ANSI_ARGS_((NameRegistry *regPtr,
-			    CONST char *name));
-static Window		RegFindName _ANSI_ARGS_((NameRegistry *regPtr,
-			    CONST char *name));
-static NameRegistry *	RegOpen _ANSI_ARGS_((Tcl_Interp *interp,
-			    TkDisplay *dispPtr, int lock));
-static void		SendEventProc _ANSI_ARGS_((ClientData clientData,
-			    XEvent *eventPtr));
-static int		SendInit _ANSI_ARGS_((Tcl_Interp *interp,
-			    TkDisplay *dispPtr));
-static Tk_RestrictAction SendRestrictProc _ANSI_ARGS_((ClientData clientData,
-			    XEvent *eventPtr));
-static int		ServerSecure _ANSI_ARGS_((TkDisplay *dispPtr));
-static void		UpdateCommWindow _ANSI_ARGS_((TkDisplay *dispPtr));
-static int		ValidateName _ANSI_ARGS_((TkDisplay *dispPtr,
-			    CONST char *name, Window commWindow, int oldOK));
+			    int length, PendingCommand *pendingPtr);
+static void		DeleteProc(ClientData clientData);
+static void		RegAddName(NameRegistry *regPtr,
+			    CONST char *name, Window commWindow);
+static void		RegClose(NameRegistry *regPtr);
+static void		RegDeleteName(NameRegistry *regPtr, CONST char *name);
+static Window		RegFindName(NameRegistry *regPtr, CONST char *name);
+static NameRegistry *	RegOpen(Tcl_Interp *interp,
+			    TkDisplay *dispPtr, int lock);
+static void		SendEventProc(ClientData clientData, XEvent *eventPtr);
+static int		SendInit(Tcl_Interp *interp, TkDisplay *dispPtr);
+static Tk_RestrictAction SendRestrictProc(ClientData clientData,
+			    XEvent *eventPtr);
+static int		ServerSecure(TkDisplay *dispPtr);
+static void		UpdateCommWindow(TkDisplay *dispPtr);
+static int		ValidateName(TkDisplay *dispPtr, CONST char *name,
+			    Window commWindow, int oldOK);
 
 /*
  *----------------------------------------------------------------------
  *
  * RegOpen --
  *
- *	This procedure loads the name registry for a display into
- *	memory so that it can be manipulated.
+ *	This function loads the name registry for a display into memory so
+ *	that it can be manipulated.
  *
  * Results:
  *	The return value is a pointer to the loaded registry.
  *
  * Side effects:
- *	If "lock" is set then the server will be locked.  It is the
- *	caller's responsibility to call RegClose when finished with
- *	the registry, so that we can write back the registry if
- *	needed, unlock the server if needed, and free memory.
+ *	If "lock" is set then the server will be locked.  It is the caller's
+ *	responsibility to call RegClose when finished with the registry, so
+ *	that we can write back the registry if needed, unlock the server if
+ *	needed, and free memory.
  *
  *----------------------------------------------------------------------
  */
 
 static NameRegistry *
-RegOpen(interp, dispPtr, lock)
-    Tcl_Interp *interp;		/* Interpreter to use for error reporting
-				 * (errors cause a panic so in fact no
-				 * error is ever returned, but the interpreter
-				 * is needed anyway). */
-    TkDisplay *dispPtr;		/* Display whose name registry is to be
+RegOpen(
+    Tcl_Interp *interp,		/* Interpreter to use for error reporting
+				 * (errors cause a panic so in fact no error
+				 * is ever returned, but the interpreter is
+				 * needed anyway). */
+    TkDisplay *dispPtr,		/* Display whose name registry is to be
 				 * opened. */
-    int lock;			/* Non-zero means lock the window server
-				 * when opening the registry, so no-one
-				 * else can use the registry until we
-				 * close it. */
+    int lock)			/* Non-zero means lock the window server when
+				 * opening the registry, so no-one else can
+				 * use the registry until we close it. */
 {
     NameRegistry *regPtr;
     int result, actualFormat;
@@ -327,11 +315,11 @@ RegOpen(interp, dispPtr, lock)
     }
 
     /*
-     * Xlib placed an extra null byte after the end of the property, just
-     * to make sure that it is always NULL-terminated.  Be sure to include
-     * this byte in our count if it's needed to ensure null termination
-     * (note: as of 8/95 I'm no longer sure why this code is needed;  seems
-     * like it shouldn't be).
+     * Xlib placed an extra null byte after the end of the property, just to
+     * make sure that it is always NULL-terminated. Be sure to include this
+     * byte in our count if it's needed to ensure null termination (note: as
+     * of 8/95 I'm no longer sure why this code is needed; seems like it
+     * shouldn't be).
      */
 
     if ((regPtr->propLength > 0)
@@ -346,14 +334,13 @@ RegOpen(interp, dispPtr, lock)
  *
  * RegFindName --
  *
- *	Given an open name registry, this procedure finds an entry
- *	with a given name, if there is one, and returns information
- *	about that entry.
+ *	Given an open name registry, this function finds an entry with a given
+ *	name, if there is one, and returns information about that entry.
  *
  * Results:
- *	The return value is the X identifier for the comm window for
- *	the application named "name", or None if there is no such
- *	entry in the registry.
+ *	The return value is the X identifier for the comm window for the
+ *	application named "name", or None if there is no such entry in the
+ *	registry.
  *
  * Side effects:
  *	None.
@@ -362,10 +349,10 @@ RegOpen(interp, dispPtr, lock)
  */
 
 static Window
-RegFindName(regPtr, name)
-    NameRegistry *regPtr;	/* Pointer to a registry opened with a
+RegFindName(
+    NameRegistry *regPtr,	/* Pointer to a registry opened with a
 				 * previous call to RegOpen. */
-    CONST char *name;		/* Name of an application. */
+    CONST char *name)		/* Name of an application. */
 {
     char *p, *entry;
     unsigned int id;
@@ -378,8 +365,8 @@ RegFindName(regPtr, name)
 	if ((*p != 0) && (strcmp(name, p+1) == 0)) {
 	    if (sscanf(entry, "%x", &id) == 1) {
 		/*
-		 * Must cast from an unsigned int to a Window in case we
-		 * are on a 64-bit architecture.
+		 * Must cast from an unsigned int to a Window in case we are
+		 * on a 64-bit architecture.
 		 */
 
 		return (Window) id;
@@ -398,25 +385,25 @@ RegFindName(regPtr, name)
  *
  * RegDeleteName --
  *
- *	This procedure deletes the entry for a given name from
- *	an open registry.
+ *	This function deletes the entry for a given name from an open
+ *	registry.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	If there used to be an entry named "name" in the registry,
- *	then it is deleted and the registry is marked as modified
- *	so it will be written back when closed.
+ *	If there used to be an entry named "name" in the registry, then it is
+ *	deleted and the registry is marked as modified so it will be written
+ *	back when closed.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-RegDeleteName(regPtr, name)
-    NameRegistry *regPtr;	/* Pointer to a registry opened with a
+RegDeleteName(
+    NameRegistry *regPtr,	/* Pointer to a registry opened with a
 				 * previous call to RegOpen. */
-    CONST char *name;		/* Name of an application. */
+    CONST char *name)		/* Name of an application. */
 {
     char *p, *entry, *entryName;
     int count;
@@ -473,13 +460,13 @@ RegDeleteName(regPtr, name)
  */
 
 static void
-RegAddName(regPtr, name, commWindow)
-    NameRegistry *regPtr;	/* Pointer to a registry opened with a
+RegAddName(
+    NameRegistry *regPtr,	/* Pointer to a registry opened with a
 				 * previous call to RegOpen. */
-    CONST char *name;		/* Name of an application.  The caller
-				 * must ensure that this name isn't
-				 * already registered. */
-    Window commWindow;		/* X identifier for comm. window of
+    CONST char *name,		/* Name of an application. The caller must
+				 * ensure that this name isn't already
+				 * registered. */
+    Window commWindow)		/* X identifier for comm. window of
 				 * application.  */
 {
     char id[30];
@@ -512,24 +499,23 @@ RegAddName(regPtr, name, commWindow)
  *
  * RegClose --
  *
- *	This procedure is called to end a series of operations on
- *	a name registry.
+ *	This function is called to end a series of operations on a name
+ *	registry.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The registry is written back if it has been modified, and the
- *	X server is unlocked if it was locked.  Memory for the
- *	registry is freed, so the caller should never use regPtr
- *	again.
+ *	The registry is written back if it has been modified, and the X server
+ *	is unlocked if it was locked. Memory for the registry is freed, so the
+ *	caller should never use regPtr again.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-RegClose(regPtr)
-    NameRegistry *regPtr;	/* Pointer to a registry opened with a
+RegClose(
+    NameRegistry *regPtr)	/* Pointer to a registry opened with a
 				 * previous call to RegOpen. */
 {
     if (regPtr->modified) {
@@ -549,11 +535,11 @@ RegClose(regPtr)
 
     /*
      * After ungrabbing the server, it's important to flush the output
-     * immediately so that the server sees the ungrab command.  Otherwise
-     * we might do something else that needs to communicate with the
-     * server (such as invoking a subprocess that needs to do I/O to
-     * the screen); if the ungrab command is still sitting in our
-     * output buffer, we could deadlock.
+     * immediately so that the server sees the ungrab command. Otherwise we
+     * might do something else that needs to communicate with the server (such
+     * as invoking a subprocess that needs to do I/O to the screen); if the
+     * ungrab command is still sitting in our output buffer, we could
+     * deadlock.
      */
 
     XFlush(regPtr->dispPtr->display);
@@ -573,12 +559,12 @@ RegClose(regPtr)
  *
  * ValidateName --
  *
- *	This procedure checks to see if an entry in the registry
- *	is still valid.
+ *	This function checks to see if an entry in the registry is still
+ *	valid.
  *
  * Results:
- *	The return value is 1 if the given commWindow exists and its
- *	name is "name".  Otherwise 0 is returned.
+ *	The return value is 1 if the given commWindow exists and its name is
+ *	"name". Otherwise 0 is returned.
  *
  * Side effects:
  *	None.
@@ -587,16 +573,16 @@ RegClose(regPtr)
  */
 
 static int
-ValidateName(dispPtr, name, commWindow, oldOK)
-    TkDisplay *dispPtr;		/* Display for which to perform the
+ValidateName(
+    TkDisplay *dispPtr,		/* Display for which to perform the
 				 * validation. */
-    CONST char *name;		/* The name of an application. */
-    Window commWindow;		/* X identifier for the application's
-				 * comm. window. */
-    int oldOK;			/* Non-zero means that we should consider
-				 * an application to be valid even if it
-				 * looks like an old-style (pre-4.0) one;
-				 * 0 means consider these invalid. */
+    CONST char *name,		/* The name of an application. */
+    Window commWindow,		/* X identifier for the application's comm.
+				 * window. */
+    int oldOK)			/* Non-zero means that we should consider an
+				 * application to be valid even if it looks
+				 * like an old-style (pre-4.0) one; 0 means
+				 * consider these invalid. */
 {
     int result, actualFormat, argc, i;
     unsigned long length, bytesAfter;
@@ -608,13 +594,12 @@ ValidateName(dispPtr, name, commWindow, oldOK)
     property = NULL;
 
     /*
-     * Ignore X errors when reading the property (e.g., the window
-     * might not exist).  If an error occurs, result will be some
-     * value other than Success.
+     * Ignore X errors when reading the property (e.g., the window might not
+     * exist). If an error occurs, result will be some value other than
+     * Success.
      */
 
-    handler = Tk_CreateErrorHandler(dispPtr->display, -1, -1, -1,
-	    (Tk_ErrorProc *) NULL, (ClientData) NULL);
+    handler = Tk_CreateErrorHandler(dispPtr->display, -1, -1, -1, NULL, NULL);
     result = XGetWindowProperty(dispPtr->display, commWindow,
 	    dispPtr->appNameProperty, 0, MAX_PROP_WORDS,
 	    False, XA_STRING, &actualType, &actualFormat,
@@ -624,15 +609,14 @@ ValidateName(dispPtr, name, commWindow, oldOK)
 	XWindowAttributes atts;
 
 	/*
-	 * The comm. window exists but the property we're looking for
-	 * doesn't exist.  This probably means that the application
-	 * comes from an older version of Tk (< 4.0) that didn't set the
-	 * property;  if this is the case, then assume for compatibility's
-	 * sake that everything's OK.  However, it's also possible that
-	 * some random application has re-used the window id for something
-	 * totally unrelated.  Check a few characteristics of the window,
-	 * such as its dimensions and mapped state, to be sure that it
-	 * still "smells" like a commWindow.
+	 * The comm. window exists but the property we're looking for doesn't
+	 * exist. This probably means that the application comes from an older
+	 * version of Tk (< 4.0) that didn't set the property; if this is the
+	 * case, then assume for compatibility's sake that everything's OK.
+	 * However, it's also possible that some random application has
+	 * re-used the window id for something totally unrelated. Check a few
+	 * characteristics of the window, such as its dimensions and mapped
+	 * state, to be sure that it still "smells" like a commWindow.
 	 */
 
 	if (!oldOK
@@ -646,8 +630,7 @@ ValidateName(dispPtr, name, commWindow, oldOK)
     } else if ((result == Success) && (actualFormat == 8)
 	   && (actualType == XA_STRING)) {
 	result = 0;
-	if (Tcl_SplitList((Tcl_Interp *) NULL, property, &argc, &argv)
-		== TCL_OK) {
+	if (Tcl_SplitList(NULL, property, &argc, &argv) == TCL_OK) {
 	    for (i = 0; i < argc; i++) {
 		if (strcmp(argv[i], name) == 0) {
 		    result = 1;
@@ -657,7 +640,7 @@ ValidateName(dispPtr, name, commWindow, oldOK)
 	    ckfree((char *) argv);
 	}
     } else {
-       result = 0;
+	result = 0;
     }
     Tk_DeleteErrorHandler(handler);
     if (property != NULL) {
@@ -671,15 +654,14 @@ ValidateName(dispPtr, name, commWindow, oldOK)
  *
  * ServerSecure --
  *
- *	Check whether a server is secure enough for us to trust
- *	Tcl scripts arriving via that server.
+ *	Check whether a server is secure enough for us to trust Tcl scripts
+ *	arriving via that server.
  *
  * Results:
- *	The return value is 1 if the server is secure, which means
- *	that host-style authentication is turned on but there are
- *	no hosts in the enabled list.  This means that some other
- *	form of authorization (presumably more secure, such as xauth)
- *	is in use.
+ *	The return value is 1 if the server is secure, which means that
+ *	host-style authentication is turned on but there are no hosts in the
+ *	enabled list. This means that some other form of authorization
+ *	(presumably more secure, such as xauth) is in use.
  *
  * Side effects:
  *	None.
@@ -688,8 +670,8 @@ ValidateName(dispPtr, name, commWindow, oldOK)
  */
 
 static int
-ServerSecure(dispPtr)
-    TkDisplay *dispPtr;		/* Display to check. */
+ServerSecure(
+    TkDisplay *dispPtr)		/* Display to check. */
 {
 #ifdef TK_NO_SECURITY
     return 1;
@@ -715,32 +697,32 @@ ServerSecure(dispPtr)
  *
  * Tk_SetAppName --
  *
- *	This procedure is called to associate an ASCII name with a Tk
- *	application.  If the application has already been named, the
- *	name replaces the old one.
+ *	This function is called to associate an ASCII name with a Tk
+ *	application. If the application has already been named, the name
+ *	replaces the old one.
  *
  * Results:
- *	The return value is the name actually given to the application.
- *	This will normally be the same as name, but if name was already
- *	in use for an application then a name of the form "name #2" will
- *	be chosen,  with a high enough number to make the name unique.
+ *	The return value is the name actually given to the application. This
+ *	will normally be the same as name, but if name was already in use for
+ *	an application then a name of the form "name #2" will be chosen, with
+ *	a high enough number to make the name unique.
  *
  * Side effects:
- *	Registration info is saved, thereby allowing the "send" command
- *	to be used later to invoke commands in the application.  In
- *	addition, the "send" command is created in the application's
- *	interpreter.  The registration will be removed automatically
- *	if the interpreter is deleted or the "send" command is removed.
+ *	Registration info is saved, thereby allowing the "send" command to be
+ *	used later to invoke commands in the application. In addition, the
+ *	"send" command is created in the application's interpreter. The
+ *	registration will be removed automatically if the interpreter is
+ *	deleted or the "send" command is removed.
  *
  *--------------------------------------------------------------
  */
 
 CONST char *
-Tk_SetAppName(tkwin, name)
-    Tk_Window tkwin;		/* Token for any window in the application
+Tk_SetAppName(
+    Tk_Window tkwin,		/* Token for any window in the application
 				 * to be named:  it is just used to identify
 				 * the application and the display.  */
-    CONST char *name;		/* The name that will be used to
+    CONST char *name)		/* The name that will be used to
 				 * refer to the interpreter in later
 				 * "send" commands.  Must be globally
 				 * unique. */
@@ -754,8 +736,8 @@ Tk_SetAppName(tkwin, name)
     CONST char *actualName;
     Tcl_DString dString;
     int offset, i;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
-            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     interp = winPtr->mainPtr->interp;
     if (dispPtr->commTkwin == NULL) {
@@ -763,18 +745,17 @@ Tk_SetAppName(tkwin, name)
     }
 
     /*
-     * See if the application is already registered;  if so, remove its
-     * current name from the registry.
+     * See if the application is already registered; if so, remove its current
+     * name from the registry.
      */
 
     regPtr = RegOpen(interp, winPtr->dispPtr, 1);
     for (riPtr = tsdPtr->interpListPtr; ; riPtr = riPtr->nextPtr) {
 	if (riPtr == NULL) {
-
 	    /*
-	     * This interpreter isn't currently registered;  create
-	     * the data structure that will be used to register it locally,
-	     * plus add the "send" command to the interpreter.
+	     * This interpreter isn't currently registered; create the data
+	     * structure that will be used to register it locally, plus add
+	     * the "send" command to the interpreter.
 	     */
 
 	    riPtr = (RegisteredInterp *) ckalloc(sizeof(RegisteredInterp));
@@ -785,15 +766,15 @@ Tk_SetAppName(tkwin, name)
 	    riPtr->name = NULL;
 	    Tcl_CreateCommand(interp, "send", Tk_SendCmd, (ClientData) riPtr,
 		    DeleteProc);
-            if (Tcl_IsSafe(interp)) {
-                Tcl_HideCommand(interp, "send", "send");
-            }
+	    if (Tcl_IsSafe(interp)) {
+		Tcl_HideCommand(interp, "send", "send");
+	    }
 	    break;
 	}
 	if (riPtr->interp == interp) {
 	    /*
-	     * The interpreter is currently registered;  remove it from
-	     * the name registry.
+	     * The interpreter is currently registered; remove it from the
+	     * name registry.
 	     */
 
 	    if (riPtr->name) {
@@ -805,10 +786,9 @@ Tk_SetAppName(tkwin, name)
     }
 
     /*
-     * Pick a name to use for the application.  Use "name" if it's not
-     * already in use.  Otherwise add a suffix such as " #2", trying
-     * larger and larger numbers until we eventually find one that is
-     * unique.
+     * Pick a name to use for the application. Use "name" if it's not already
+     * in use. Otherwise add a suffix such as " #2", trying larger and larger
+     * numbers until we eventually find one that is unique.
      */
 
     actualName = name;
@@ -830,16 +810,16 @@ Tk_SetAppName(tkwin, name)
 	if (w == None) {
 	    break;
 	}
-    
+
 	/*
-	 * The name appears to be in use already, but double-check to
-	 * be sure (perhaps the application died without removing its
-	 * name from the registry?).
+	 * The name appears to be in use already, but double-check to be sure
+	 * (perhaps the application died without removing its name from the
+	 * registry?).
 	 */
 
 	if (w == Tk_WindowId(dispPtr->commTkwin)) {
-	    for (riPtr2 = tsdPtr->interpListPtr; riPtr2 != NULL; 
-                    riPtr2 = riPtr2->nextPtr) {
+	    for (riPtr2 = tsdPtr->interpListPtr; riPtr2 != NULL;
+		    riPtr2 = riPtr2->nextPtr) {
 		if ((riPtr2->interp != interp) &&
 			(strcmp(riPtr2->name, actualName) == 0)) {
 		    goto nextSuffix;
@@ -856,9 +836,9 @@ Tk_SetAppName(tkwin, name)
     }
 
     /*
-     * We've now got a name to use.  Store it in the name registry and
-     * in the local entry for this application, plus put it in a property
-     * on the commWindow.
+     * We've now got a name to use. Store it in the name registry and in the
+     * local entry for this application, plus put it in a property on the
+     * commWindow.
      */
 
     RegAddName(regPtr, actualName, Tk_WindowId(dispPtr->commTkwin));
@@ -878,8 +858,8 @@ Tk_SetAppName(tkwin, name)
  *
  * Tk_SendCmd --
  *
- *	This procedure is invoked to process the "send" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "send" Tcl command. See the
+ *	user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -891,12 +871,12 @@ Tk_SetAppName(tkwin, name)
  */
 
 int
-Tk_SendCmd(clientData, interp, argc, argv)
-    ClientData clientData;		/* Information about sender (only
-					 * dispPtr field is used). */
-    Tcl_Interp *interp;			/* Current interpreter. */
-    int argc;				/* Number of arguments. */
-    CONST char **argv;			/* Argument strings. */
+Tk_SendCmd(
+    ClientData clientData,	/* Information about sender (only dispPtr
+				 * field is used). */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int argc,			/* Number of arguments. */
+    CONST char **argv)		/* Argument strings. */
 {
     TkWindow *winPtr;
     Window commWindow;
@@ -911,11 +891,10 @@ Tk_SendCmd(clientData, interp, argc, argv)
     Tcl_Time timeout;
     NameRegistry *regPtr;
     Tcl_DString request;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
-            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
-    Tcl_Interp *localInterp;		/* Used when the interpreter to
-                                         * send the command to is within
-                                         * the same process. */
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    Tcl_Interp *localInterp;	/* Used when the interpreter to send the
+				 * command to is within the same process. */
 
     /*
      * Process options, if any.
@@ -948,14 +927,14 @@ Tk_SendCmd(clientData, interp, argc, argv)
 	    break;
 	} else {
 	    Tcl_AppendResult(interp, "bad option \"", argv[i],
-		    "\": must be -async, -displayof, or --", (char *) NULL);
+		    "\": must be -async, -displayof, or --", NULL);
 	    return TCL_ERROR;
 	}
     }
 
     if (argc < (i+2)) {
 	Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-		" ?options? interpName arg ?arg ...?\"", (char *) NULL);
+		" ?options? interpName arg ?arg ...?\"", NULL);
 	return TCL_ERROR;
     }
     destName = argv[i];
@@ -967,22 +946,21 @@ Tk_SendCmd(clientData, interp, argc, argv)
     }
 
     /*
-     * See if the target interpreter is local.  If so, execute
-     * the command directly without going through the X server.
-     * The only tricky thing is passing the result from the target
-     * interpreter to the invoking interpreter.  Watch out:  they
-     * could be the same!
+     * See if the target interpreter is local. If so, execute the command
+     * directly without going through the X server. The only tricky thing is
+     * passing the result from the target interpreter to the invoking
+     * interpreter. Watch out: they could be the same!
      */
 
-    for (riPtr = tsdPtr->interpListPtr; riPtr != NULL; 
-            riPtr = riPtr->nextPtr) {
+    for (riPtr = tsdPtr->interpListPtr; riPtr != NULL;
+	    riPtr = riPtr->nextPtr) {
 	if ((riPtr->dispPtr != dispPtr)
 		|| (strcmp(riPtr->name, destName) != 0)) {
 	    continue;
 	}
 	Tcl_Preserve((ClientData) riPtr);
-        localInterp = riPtr->interp;
-        Tcl_Preserve((ClientData) localInterp);
+	localInterp = riPtr->interp;
+	Tcl_Preserve((ClientData) localInterp);
 	if (firstArg == (argc-1)) {
 	    result = Tcl_GlobalEval(localInterp, argv[firstArg]);
 	} else {
@@ -1001,25 +979,25 @@ Tk_SendCmd(clientData, interp, argc, argv)
 
 		/*
 		 * An error occurred, so transfer error information from the
-		 * destination interpreter back to our interpreter.  Must clear
+		 * destination interpreter back to our interpreter. Must clear
 		 * interp's result before calling Tcl_AddErrorInfo, since
-		 * Tcl_AddErrorInfo will store the interp's result in errorInfo
-		 * before appending riPtr's $errorInfo;  we've already got
-		 * everything we need in riPtr's $errorInfo.
+		 * Tcl_AddErrorInfo will store the interp's result in
+		 * errorInfo before appending riPtr's $errorInfo; we've
+		 * already got everything we need in riPtr's $errorInfo.
 		 */
 
 		Tcl_ResetResult(interp);
 		Tcl_AddErrorInfo(interp, Tcl_GetVar2(localInterp,
-			"errorInfo", (char *) NULL, TCL_GLOBAL_ONLY));
+			"errorInfo", NULL, TCL_GLOBAL_ONLY));
 		errorObjPtr = Tcl_GetVar2Ex(localInterp, "errorCode", NULL,
 			TCL_GLOBAL_ONLY);
 		Tcl_SetObjErrorCode(interp, errorObjPtr);
 	    }
 	    Tcl_SetObjResult(interp, Tcl_GetObjResult(localInterp));
-            Tcl_ResetResult(localInterp);
+	    Tcl_ResetResult(localInterp);
 	}
 	Tcl_Release((ClientData) riPtr);
-        Tcl_Release((ClientData) localInterp);
+	Tcl_Release((ClientData) localInterp);
 	return result;
     }
 
@@ -1031,14 +1009,13 @@ Tk_SendCmd(clientData, interp, argc, argv)
     commWindow = RegFindName(regPtr, destName);
     RegClose(regPtr);
     if (commWindow == None) {
-	Tcl_AppendResult(interp, "no application named \"",
-		destName, "\"", (char *) NULL);
+	Tcl_AppendResult(interp, "no application named \"",destName,"\"",NULL);
 	return TCL_ERROR;
     }
 
     /*
-     * Send the command to the target interpreter by appending it to the
-     * comm window in the communication window.
+     * Send the command to the target interpreter by appending it to the comm
+     * window in the communication window.
      */
 
     tkSendSerial++;
@@ -1062,24 +1039,23 @@ Tk_SendCmd(clientData, interp, argc, argv)
     }
     (void) AppendPropCarefully(dispPtr->display, commWindow,
 	    dispPtr->commProperty, Tcl_DStringValue(&request),
-	    Tcl_DStringLength(&request) + 1,
-	    (async) ? (PendingCommand *) NULL : &pending);
+	    Tcl_DStringLength(&request) + 1, (async ? NULL : &pending));
     Tcl_DStringFree(&request);
     if (async) {
 	/*
-	 * This is an asynchronous send:  return immediately without
-	 * waiting for a response.
+	 * This is an asynchronous send: return immediately without waiting
+	 * for a response.
 	 */
 
 	return TCL_OK;
     }
 
     /*
-     * Register the fact that we're waiting for a command to complete
-     * (this is needed by SendEventProc and by AppendErrorProc to pass
-     * back the command's results).  Set up a timeout handler so that
-     * we can check during long sends to make sure that the destination
-     * application is still alive.
+     * Register the fact that we're waiting for a command to complete (this is
+     * needed by SendEventProc and by AppendErrorProc to pass back the
+     * command's results). Set up a timeout handler so that we can check
+     * during long sends to make sure that the destination application is
+     * still alive.
      */
 
     pending.serial = tkSendSerial;
@@ -1095,28 +1071,27 @@ Tk_SendCmd(clientData, interp, argc, argv)
     tsdPtr->pendingCommands = &pending;
 
     /*
-     * Enter a loop processing X events until the result comes
-     * in or the target is declared to be dead.  While waiting
-     * for a result, look only at send-related events so that
-     * the send is synchronous with respect to other events in
-     * the application.
+     * Enter a loop processing X events until the result comes in or the
+     * target is declared to be dead. While waiting for a result, look only at
+     * send-related events so that the send is synchronous with respect to
+     * other events in the application.
      */
 
-    prevRestrictProc = Tk_RestrictEvents(SendRestrictProc,
-	    (ClientData) NULL, &prevArg);
+    prevRestrictProc = Tk_RestrictEvents(SendRestrictProc, NULL, &prevArg);
     Tcl_GetTime(&timeout);
     timeout.sec += 2;
     while (!pending.gotResponse) {
 	if (!TkUnixDoOneXEvent(&timeout)) {
 	    /*
 	     * An unusually long amount of time has elapsed during the
-	     * processing of a sent command.  Check to make sure that the
-	     * target application still exists.  If it does, reset the timeout.
+	     * processing of a sent command. Check to make sure that the
+	     * target application still exists. If it does, reset the timeout.
 	     */
 
 	    if (!ValidateName(pending.dispPtr, pending.target,
 		    pending.commWindow, 0)) {
 		char *msg;
+
 		if (ValidateName(pending.dispPtr, pending.target,
 			pending.commWindow, 1)) {
 		    msg = "target application died or uses a Tk version before 4.0";
@@ -1136,8 +1111,8 @@ Tk_SendCmd(clientData, interp, argc, argv)
     (void) Tk_RestrictEvents(prevRestrictProc, prevArg, &prevArg);
 
     /*
-     * Unregister the information about the pending command
-     * and return the result.
+     * Unregister the information about the pending command and return the
+     * result.
      */
 
     if (tsdPtr->pendingCommands != &pending) {
@@ -1148,7 +1123,7 @@ Tk_SendCmd(clientData, interp, argc, argv)
 	/*
 	 * Special trick: must clear the interp's result before calling
 	 * Tcl_AddErrorInfo, since Tcl_AddErrorInfo will store the interp's
-	 * result in errorInfo before appending pending.errorInfo;  we've
+	 * result in errorInfo before appending pending.errorInfo; we've
 	 * already got everything we need in pending.errorInfo.
 	 */
 
@@ -1171,15 +1146,14 @@ Tk_SendCmd(clientData, interp, argc, argv)
  *
  * TkGetInterpNames --
  *
- *	This procedure is invoked to fetch a list of all the
- *	interpreter names currently registered for the display
- *	of a particular window.
+ *	This function is invoked to fetch a list of all the interpreter names
+ *	currently registered for the display of a particular window.
  *
  * Results:
- *	A standard Tcl return value.  The interp's result will be set
- *	to hold a list of all the interpreter names defined for
- *	tkwin's display.  If an error occurs, then TCL_ERROR
- *	is returned and the interp's result will hold an error message.
+ *	A standard Tcl return value. The interp's result will be set to hold a
+ *	list of all the interpreter names defined for tkwin's display. If an
+ *	error occurs, then TCL_ERROR is returned and the interp's result will
+ *	hold an error message.
  *
  * Side effects:
  *	None.
@@ -1188,10 +1162,10 @@ Tk_SendCmd(clientData, interp, argc, argv)
  */
 
 int
-TkGetInterpNames(interp, tkwin)
-    Tcl_Interp *interp;		/* Interpreter for returning a result. */
-    Tk_Window tkwin;		/* Window whose display is to be used
-				 * for the lookup. */
+TkGetInterpNames(
+    Tcl_Interp *interp,		/* Interpreter for returning a result. */
+    Tk_Window tkwin)		/* Window whose display is to be used for the
+				 * lookup. */
 {
     TkWindow *winPtr = (TkWindow *) tkwin;
     char *p, *entry, *entryName;
@@ -1208,7 +1182,7 @@ TkGetInterpNames(interp, tkwin)
     regPtr = RegOpen(interp, winPtr->dispPtr, 1);
     for (p = regPtr->property; (p-regPtr->property) < (int) regPtr->propLength; ) {
 	entry = p;
-	if (sscanf(p,  "%x",(unsigned int *) &id) != 1) {
+	if (sscanf(p, "%x",(unsigned int *) &id) != 1) {
 	    commWindow =  None;
 	} else {
 	    commWindow = id;
@@ -1233,7 +1207,7 @@ TkGetInterpNames(interp, tkwin)
 	} else {
 	    /*
 	     * This name is bogus (perhaps the application died without
-	     * cleaning up its entry in the registry?).  Delete the name.
+	     * cleaning up its entry in the registry?). Delete the name.
 	     */
 
 	    count = regPtr->propLength - (p - regPtr->property);
@@ -1258,9 +1232,8 @@ TkGetInterpNames(interp, tkwin)
  *
  * TkSendCleanup --
  *
- *	This procedure is called to free resources used by the
- *	communication channels for sending commands and
- *	receiving results.
+ *	This function is called to free resources used by the communication
+ *	channels for sending commands and receiving results.
  *
  * Results:
  *	None.
@@ -1272,8 +1245,8 @@ TkGetInterpNames(interp, tkwin)
  */
 
 void
-TkSendCleanup(dispPtr)
-    TkDisplay *dispPtr;
+TkSendCleanup(
+    TkDisplay *dispPtr)
 {
     if (dispPtr->commTkwin != NULL) {
 	Tk_DeleteEventHandler(dispPtr->commTkwin, PropertyChangeMask,
@@ -1289,9 +1262,8 @@ TkSendCleanup(dispPtr)
  *
  * SendInit --
  *
- *	This procedure is called to initialize the
- *	communication channels for sending commands and
- *	receiving results.
+ *	This function is called to initialize the communication channels for
+ *	sending commands and receiving results.
  *
  * Results:
  *	None.
@@ -1303,17 +1275,17 @@ TkSendCleanup(dispPtr)
  */
 
 static int
-SendInit(interp, dispPtr)
-    Tcl_Interp *interp;		/* Interpreter to use for error reporting
-				 * (no errors are ever returned, but the
+SendInit(
+    Tcl_Interp *interp,		/* Interpreter to use for error reporting (no
+				 * errors are ever returned, but the
 				 * interpreter is needed anyway). */
-    TkDisplay *dispPtr;		/* Display to initialize. */
+    TkDisplay *dispPtr)		/* Display to initialize. */
 {
     XSetWindowAttributes atts;
 
     /*
-     * Create the window used for communication, and set up an
-     * event handler for it.
+     * Create the window used for communication, and set up an event handler
+     * for it.
      */
 
     dispPtr->commTkwin = Tk_CreateWindow(interp, (Tk_Window) NULL,
@@ -1347,27 +1319,25 @@ SendInit(interp, dispPtr)
  *
  * SendEventProc --
  *
- *	This procedure is invoked automatically by the toolkit
- *	event manager when a property changes on the communication
- *	window.  This procedure reads the property and handles
- *	command requests and responses.
+ *	This function is invoked automatically by the toolkit event manager
+ *	when a property changes on the communication window. This function
+ *	reads the property and handles command requests and responses.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	If there are command requests in the property, they
- *	are executed.  If there are responses in the property,
- *	their information is saved for the (ostensibly waiting)
- *	"send" commands. The property is deleted.
+ *	If there are command requests in the property, they are executed. If
+ *	there are responses in the property, their information is saved for
+ *	the (ostensibly waiting) "send" commands. The property is deleted.
  *
  *--------------------------------------------------------------
  */
 
 static void
-SendEventProc(clientData, eventPtr)
-    ClientData clientData;	/* Display information. */	
-    XEvent *eventPtr;		/* Information about event. */
+SendEventProc(
+    ClientData clientData,	/* Display information. */
+    XEvent *eventPtr)		/* Information about event. */
 {
     TkDisplay *dispPtr = (TkDisplay *) clientData;
     char *propInfo;
@@ -1376,8 +1346,8 @@ SendEventProc(clientData, eventPtr)
     unsigned long numItems, bytesAfter;
     Atom actualType;
     Tcl_Interp *remoteInterp;	/* Interp in which to execute the command. */
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
-            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     if ((eventPtr->xproperty.atom != dispPtr->commProperty)
 	    || (eventPtr->xproperty.state != PropertyNewValue)) {
@@ -1396,8 +1366,7 @@ SendEventProc(clientData, eventPtr)
 	    &numItems, &bytesAfter, (unsigned char **) &propInfo);
 
     /*
-     * If the property doesn't exist or is improperly formed
-     * then ignore it.
+     * If the property doesn't exist or is improperly formed then ignore it.
      */
 
     if ((result != Success) || (actualType != XA_STRING)
@@ -1409,17 +1378,16 @@ SendEventProc(clientData, eventPtr)
     }
 
     /*
-     * Several commands and results could arrive in the property at
-     * one time;  each iteration through the outer loop handles a
-     * single command or result.
+     * Several commands and results could arrive in the property at one time;
+     * each iteration through the outer loop handles a single command or
+     * result.
      */
 
     for (p = propInfo; (p-propInfo) < (int) numItems; ) {
 	/*
-	 * Ignore leading NULLs; each command or result starts with a
-	 * NULL so that no matter how badly formed a preceding command
-	 * is, we'll be able to tell that a new command/result is
-	 * starting.
+	 * Ignore leading NULLs; each command or result starts with a NULL so
+	 * that no matter how badly formed a preceding command is, we'll be
+	 * able to tell that a new command/result is starting.
 	 */
 
 	if (*p == 0) {
@@ -1436,9 +1404,8 @@ SendEventProc(clientData, eventPtr)
 	    /*
 	     *----------------------------------------------------------
 	     * This is an incoming command from some other application.
-	     * Iterate over all of its options.  Stop when we reach
-	     * the end of the property or something that doesn't look
-	     * like an option.
+	     * Iterate over all of its options. Stop when we reach the end of
+	     * the property or something that doesn't look like an option.
 	     *----------------------------------------------------------
 	     */
 
@@ -1449,24 +1416,24 @@ SendEventProc(clientData, eventPtr)
 	    script = NULL;
 	    while (((p-propInfo) < (int) numItems) && (*p == '-')) {
 		switch (p[1]) {
-		    case 'r':
-			commWindow = (Window) strtoul(p+2, &end, 16);
-			if ((end == p+2) || (*end != ' ')) {
-			    commWindow = None;
-			} else {
-			    p = serial = end+1;
-			}
-			break;
-		    case 'n':
-			if (p[2] == ' ') {
-			    interpName = p+3;
-			}
-			break;
-		    case 's':
-			if (p[2] == ' ') {
-			    script = p+3;
-			}
-			break;
+		case 'r':
+		    commWindow = (Window) strtoul(p+2, &end, 16);
+		    if ((end == p+2) || (*end != ' ')) {
+			commWindow = None;
+		    } else {
+			p = serial = end+1;
+		    }
+		    break;
+		case 'n':
+		    if (p[2] == ' ') {
+			interpName = p+3;
+		    }
+		    break;
+		case 's':
+		    if (p[2] == ' ') {
+			script = p+3;
+		    }
+		    break;
 		}
 		while (*p != 0) {
 		    p++;
@@ -1479,8 +1446,8 @@ SendEventProc(clientData, eventPtr)
 	    }
 
 	    /*
-	     * Initialize the result property, so that we're ready at any
-	     * time if we need to return an error.
+	     * Initialize the result property, so that we're ready at any time
+	     * if we need to return an error.
 	     */
 
 	    if (commWindow != None) {
@@ -1519,66 +1486,65 @@ SendEventProc(clientData, eventPtr)
 	    }
 	    Tcl_Preserve((ClientData) riPtr);
 
-            /*
-             * We must protect the interpreter because the script may
-             * enter another event loop, which might call Tcl_DeleteInterp.
-             */
+	    /*
+	     * We must protect the interpreter because the script may enter
+	     * another event loop, which might call Tcl_DeleteInterp.
+	     */
 
-            remoteInterp = riPtr->interp;
-            Tcl_Preserve((ClientData) remoteInterp);
+	    remoteInterp = riPtr->interp;
+	    Tcl_Preserve((ClientData) remoteInterp);
 
-            result = Tcl_GlobalEval(remoteInterp, script);
+	    result = Tcl_GlobalEval(remoteInterp, script);
 
-            /*
-             * The call to Tcl_Release may have released the interpreter
-             * which will cause the "send" command for that interpreter
-             * to be deleted. The command deletion callback will set the
-             * riPtr->interp field to NULL, hence the check below for NULL.
-             */
+	    /*
+	     * The call to Tcl_Release may have released the interpreter which
+	     * will cause the "send" command for that interpreter to be
+	     * deleted. The command deletion callback will set the
+	     * riPtr->interp field to NULL, hence the check below for NULL.
+	     */
 
 	    if (commWindow != None) {
 		Tcl_DStringAppend(&reply, Tcl_GetStringResult(remoteInterp),
 			-1);
 		if (result == TCL_ERROR) {
 		    CONST char *varValue;
-    
+
 		    varValue = Tcl_GetVar2(remoteInterp, "errorInfo",
-			    (char *) NULL, TCL_GLOBAL_ONLY);
+			    NULL, TCL_GLOBAL_ONLY);
 		    if (varValue != NULL) {
 			Tcl_DStringAppend(&reply, "\0-i ", 4);
 			Tcl_DStringAppend(&reply, varValue, -1);
 		    }
 		    varValue = Tcl_GetVar2(remoteInterp, "errorCode",
-			    (char *) NULL, TCL_GLOBAL_ONLY);
+			    NULL, TCL_GLOBAL_ONLY);
 		    if (varValue != NULL) {
 			Tcl_DStringAppend(&reply, "\0-e ", 4);
 			Tcl_DStringAppend(&reply, varValue, -1);
 		    }
 		}
 	    }
-            Tcl_Release((ClientData) remoteInterp);
+	    Tcl_Release((ClientData) remoteInterp);
 	    Tcl_Release((ClientData) riPtr);
 
 	    /*
-	     * Return the result to the sender if a commWindow was
-	     * specified (if none was specified then this is an asynchronous
-	     * call).  Right now reply has everything but the completion
-	     * code, but it needs the NULL to terminate the current option.
+	     * Return the result to the sender if a commWindow was specified
+	     * (if none was specified then this is an asynchronous call).
+	     * Right now reply has everything but the completion code, but it
+	     * needs the NULL to terminate the current option.
 	     */
 
-	    returnResult:
+	returnResult:
 	    if (commWindow != None) {
 		if (result != TCL_OK) {
 		    char buffer[TCL_INTEGER_SPACE];
-    
+
 		    sprintf(buffer, "%d", result);
 		    Tcl_DStringAppend(&reply, "\0-c ", 4);
 		    Tcl_DStringAppend(&reply, buffer, -1);
 		}
 		(void) AppendPropCarefully(dispPtr->display, commWindow,
 			dispPtr->commProperty, Tcl_DStringValue(&reply),
-			Tcl_DStringLength(&reply) + 1,
-			(PendingCommand *) NULL);
+			Tcl_DStringLength(&reply) + 1, NULL);
 		XFlush(dispPtr->display);
 		Tcl_DStringFree(&reply);
 	    }
@@ -1589,9 +1555,9 @@ SendEventProc(clientData, eventPtr)
 
 	    /*
 	     *----------------------------------------------------------
-	     * This is a reply to some command that we sent out.  Iterate
-	     * over all of its options.  Stop when we reach the end of the
-	     * property or something that doesn't look like an option.
+	     * This is a reply to some command that we sent out. Iterate over
+	     * all of its options. Stop when we reach the end of the property
+	     * or something that doesn't look like an option.
 	     *----------------------------------------------------------
 	     */
 
@@ -1603,31 +1569,31 @@ SendEventProc(clientData, eventPtr)
 	    resultString = "";
 	    while (((p-propInfo) < (int) numItems) && (*p == '-')) {
 		switch (p[1]) {
-		    case 'c':
-			if (sscanf(p+2, " %d", &code) != 1) {
-			    code = TCL_OK;
-			}
-			break;
-		    case 'e':
-			if (p[2] == ' ') {
-			    errorCode = p+3;
-			}
-			break;
-		    case 'i':
-			if (p[2] == ' ') {
-			    errorInfo = p+3;
-			}
-			break;
-		    case 'r':
-			if (p[2] == ' ') {
-			    resultString = p+3;
-			}
-			break;
-		    case 's':
-			if (sscanf(p+2, " %d", &serial) == 1) {
-			    gotSerial = 1;
-			}
-			break;
+		case 'c':
+		    if (sscanf(p+2, " %d", &code) != 1) {
+			code = TCL_OK;
+		    }
+		    break;
+		case 'e':
+		    if (p[2] == ' ') {
+			errorCode = p+3;
+		    }
+		    break;
+		case 'i':
+		    if (p[2] == ' ') {
+			errorInfo = p+3;
+		    }
+		    break;
+		case 'r':
+		    if (p[2] == ' ') {
+			resultString = p+3;
+		    }
+		    break;
+		case 's':
+		    if (sscanf(p+2, " %d", &serial) == 1) {
+			gotSerial = 1;
+		    }
+		    break;
 		}
 		while (*p != 0) {
 		    p++;
@@ -1640,8 +1606,7 @@ SendEventProc(clientData, eventPtr)
 	    }
 
 	    /*
-	     * Give the result information to anyone who's
-	     * waiting for it.
+	     * Give the result information to anyone who's waiting for it.
 	     */
 
 	    for (pcPtr = tsdPtr->pendingCommands; pcPtr != NULL;
@@ -1672,8 +1637,8 @@ SendEventProc(clientData, eventPtr)
 	    }
 	} else {
 	    /*
-	     * Didn't recognize this thing.  Just skip through the next
-	     * null character and try again.
+	     * Didn't recognize this thing. Just skip through the next null
+	     * character and try again.
 	     */
 
 	    while (*p != 0) {
@@ -1690,60 +1655,56 @@ SendEventProc(clientData, eventPtr)
  *
  * AppendPropCarefully --
  *
- *	Append a given property to a given window, but set up
- *	an X error handler so that if the append fails this
- *	procedure can return an error code rather than having
- *	Xlib panic.
+ *	Append a given property to a given window, but set up an X error
+ *	handler so that if the append fails this function can return an error
+ *	code rather than having Xlib panic.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The given property on the given window is appended to.
- *	If this operation fails and if pendingPtr is non-NULL,
- *	then the pending operation is marked as complete with
- *	an error.
+ *	The given property on the given window is appended to. If this
+ *	operation fails and if pendingPtr is non-NULL, then the pending
+ *	operation is marked as complete with an error.
  *
  *--------------------------------------------------------------
  */
 
 static void
-AppendPropCarefully(display, window, property, value, length, pendingPtr)
-    Display *display;		/* Display on which to operate. */
-    Window window;		/* Window whose property is to
-				 * be modified. */
-    Atom property;		/* Name of property. */
-    char *value;		/* Characters to append to property. */
-    int length;			/* Number of bytes to append. */
-    PendingCommand *pendingPtr;	/* Pending command to mark complete
-				 * if an error occurs during the
-				 * property op.  NULL means just
-				 * ignore the error. */
+AppendPropCarefully(
+    Display *display,		/* Display on which to operate. */
+    Window window,		/* Window whose property is to be modified. */
+    Atom property,		/* Name of property. */
+    char *value,		/* Characters to append to property. */
+    int length,			/* Number of bytes to append. */
+    PendingCommand *pendingPtr)	/* Pending command to mark complete if an
+				 * error occurs during the property op. NULL
+				 * means just ignore the error. */
 {
     Tk_ErrorHandler handler;
 
     handler = Tk_CreateErrorHandler(display, -1, -1, -1, AppendErrorProc,
-	(ClientData) pendingPtr);
+	    (ClientData) pendingPtr);
     XChangeProperty(display, window, property, XA_STRING, 8,
 	    PropModeAppend, (unsigned char *) value, length);
     Tk_DeleteErrorHandler(handler);
 }
 
 /*
- * The procedure below is invoked if an error occurs during
- * the XChangeProperty operation above.
+ * The function below is invoked if an error occurs during the XChangeProperty
+ * operation above.
  */
 
 	/* ARGSUSED */
 static int
-AppendErrorProc(clientData, errorPtr)
-    ClientData clientData;	/* Command to mark complete, or NULL. */
-    XErrorEvent *errorPtr;	/* Information about error. */
+AppendErrorProc(
+    ClientData clientData,	/* Command to mark complete, or NULL. */
+    XErrorEvent *errorPtr)	/* Information about error. */
 {
     PendingCommand *pendingPtr = (PendingCommand *) clientData;
     register PendingCommand *pcPtr;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
-            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     if (pendingPtr == NULL) {
 	return 0;
@@ -1773,8 +1734,8 @@ AppendErrorProc(clientData, errorPtr)
  *
  * DeleteProc --
  *
- *	This procedure is invoked by Tcl when the "send" command
- *	is deleted in an interpreter.  It unregisters the interpreter.
+ *	This function is invoked by Tcl when the "send" command is deleted in
+ *	an interpreter. It unregisters the interpreter.
  *
  * Results:
  *	None.
@@ -1786,15 +1747,15 @@ AppendErrorProc(clientData, errorPtr)
  */
 
 static void
-DeleteProc(clientData)
-    ClientData clientData;	/* Info about registration, passed
-				 * as ClientData. */
+DeleteProc(
+    ClientData clientData)	/* Info about registration, passed as
+				 * ClientData. */
 {
     RegisteredInterp *riPtr = (RegisteredInterp *) clientData;
     register RegisteredInterp *riPtr2;
     NameRegistry *regPtr;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
-            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     regPtr = RegOpen(riPtr->interp, riPtr->dispPtr, 1);
     RegDeleteName(regPtr, riPtr->name);
@@ -1822,13 +1783,12 @@ DeleteProc(clientData)
  *
  * SendRestrictProc --
  *
- *	This procedure filters incoming events when a "send" command
- *	is outstanding.  It defers all events except those containing
- *	send commands and results.
+ *	This function filters incoming events when a "send" command is
+ *	outstanding. It defers all events except those containing send
+ *	commands and results.
  *
  * Results:
- *	False is returned except for property-change events on a
- *	commWindow.
+ *	False is returned except for property-change events on a commWindow.
  *
  * Side effects:
  *	None.
@@ -1838,17 +1798,17 @@ DeleteProc(clientData)
 
     /* ARGSUSED */
 static Tk_RestrictAction
-SendRestrictProc(clientData, eventPtr)
-    ClientData clientData;		/* Not used. */
-    register XEvent *eventPtr;		/* Event that just arrived. */
+SendRestrictProc(
+    ClientData clientData,		/* Not used. */
+    register XEvent *eventPtr)		/* Event that just arrived. */
 {
     TkDisplay *dispPtr;
 
     if (eventPtr->type != PropertyNotify) {
 	return TK_DEFER_EVENT;
     }
-    for (dispPtr = TkGetDisplayList(); dispPtr != NULL; 
-            dispPtr = dispPtr->nextPtr) {
+    for (dispPtr = TkGetDisplayList(); dispPtr != NULL;
+	    dispPtr = dispPtr->nextPtr) {
 	if ((eventPtr->xany.display == dispPtr->display)
 		&& (eventPtr->xproperty.window
 		== Tk_WindowId(dispPtr->commTkwin))) {
@@ -1863,9 +1823,9 @@ SendRestrictProc(clientData, eventPtr)
  *
  * UpdateCommWindow --
  *
- *	This procedure updates the list of application names stored
- *	on our commWindow.  It is typically called when interpreters
- *	are registered and unregistered.
+ *	This function updates the list of application names stored on our
+ *	commWindow. It is typically called when interpreters are registered
+ *	and unregistered.
  *
  * Results:
  *	None.
@@ -1877,18 +1837,18 @@ SendRestrictProc(clientData, eventPtr)
  */
 
 static void
-UpdateCommWindow(dispPtr)
-    TkDisplay *dispPtr;		/* Display whose commWindow is to be
+UpdateCommWindow(
+    TkDisplay *dispPtr)		/* Display whose commWindow is to be
 				 * updated. */
 {
     Tcl_DString names;
     RegisteredInterp *riPtr;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
-            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     Tcl_DStringInit(&names);
-    for (riPtr = tsdPtr->interpListPtr; riPtr != NULL; 
-            riPtr = riPtr->nextPtr) {
+    for (riPtr = tsdPtr->interpListPtr; riPtr != NULL;
+	    riPtr = riPtr->nextPtr) {
 	Tcl_DStringAppendElement(&names, riPtr->name);
     }
     XChangeProperty(dispPtr->display, Tk_WindowId(dispPtr->commTkwin),
@@ -1897,3 +1857,11 @@ UpdateCommWindow(dispPtr)
 	    Tcl_DStringLength(&names));
     Tcl_DStringFree(&names);
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tkUnixWm.c b/unix/tkUnixWm.c
index d8fe42c..d85a9db 100644
--- a/unix/tkUnixWm.c
+++ b/unix/tkUnixWm.c
@@ -2,17 +2,17 @@
  * tkUnixWm.c --
  *
  *	This module takes care of the interactions between a Tk-based
- *	application and the window manager.  Among other things, it
- *	implements the "wm" command and passes geometry information
- *	to the window manager.
+ *	application and the window manager. Among other things, it implements
+ *	the "wm" command and passes geometry information to the window
+ *	manager.
  *
  * Copyright (c) 1991-1994 The Regents of the University of California.
  * Copyright (c) 1994-1997 Sun Microsystems, Inc.
  *
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkUnixWm.c,v 1.48 2005/04/07 20:14:39 mdejong Exp $
+ * RCS: @(#) $Id: tkUnixWm.c,v 1.49 2005/10/21 01:51:45 dkf Exp $
  */
 
 #include "tkPort.h"
@@ -20,25 +20,23 @@
 #include "tkUnixInt.h"
 
 /*
- * A data structure of the following type holds information for
- * each window manager protocol (such as WM_DELETE_WINDOW) for
- * which a handler (i.e. a Tcl command) has been defined for a
- * particular top-level window.
+ * A data structure of the following type holds information for each window
+ * manager protocol (such as WM_DELETE_WINDOW) for which a handler (i.e. a Tcl
+ * command) has been defined for a particular top-level window.
  */
 
 typedef struct ProtocolHandler {
     Atom protocol;		/* Identifies the protocol. */
     struct ProtocolHandler *nextPtr;
-				/* Next in list of protocol handlers for
-				 * the same top-level window, or NULL for
-				 * end of list. */
+				/* Next in list of protocol handlers for the
+				 * same top-level window, or NULL for end of
+				 * list. */
     Tcl_Interp *interp;		/* Interpreter in which to invoke command. */
-    char command[4];		/* Tcl command to invoke when a client
-				 * message for this protocol arrives.
-				 * The actual size of the structure varies
-				 * to accommodate the needs of the actual
-				 * command. THIS MUST BE THE LAST FIELD OF
-				 * THE STRUCTURE. */
+    char command[4];		/* Tcl command to invoke when a client message
+				 * for this protocol arrives. The actual size
+				 * of the structure varies to accommodate the
+				 * needs of the actual command. THIS MUST BE
+				 * THE LAST FIELD OF THE STRUCTURE. */
 } ProtocolHandler;
 
 #define HANDLER_SIZE(cmdLength) \
@@ -50,113 +48,112 @@ typedef struct ProtocolHandler {
  */
 
 typedef struct TkWmInfo {
-    TkWindow *winPtr;		/* Pointer to main Tk information for
-				 * this window. */
+    TkWindow *winPtr;		/* Pointer to main Tk information for this
+				 * window. */
     Window reparent;		/* If the window has been reparented, this
 				 * gives the ID of the ancestor of the window
-				 * that is a child of the root window (may
-				 * not be window's immediate parent).  If
-				 * the window isn't reparented, this has the
-				 * value None. */
-    char *title;		/* Title to display in window caption.  If
-				 * NULL, use name of widget.  Malloced. */
-    char *iconName;		/* Name to display in icon.  Malloced. */
-    XWMHints hints;		/* Various pieces of information for
-				 * window manager. */
+				 * that is a child of the root window (may not
+				 * be window's immediate parent). If the
+				 * window isn't reparented, this has the value
+				 * None. */
+    char *title;		/* Title to display in window caption. If
+				 * NULL, use name of widget. Malloced. */
+    char *iconName;		/* Name to display in icon. Malloced. */
+    XWMHints hints;		/* Various pieces of information for window
+				 * manager. */
     char *leaderName;		/* Path name of leader of window group
 				 * (corresponds to hints.window_group).
-				 * Malloc-ed.  Note:  this field doesn't
-				 * get updated if leader is destroyed. */
+				 * Malloc-ed. Note: this field doesn't get
+				 * updated if leader is destroyed. */
     TkWindow *masterPtr;	/* Master window for TRANSIENT_FOR property,
 				 * or NULL. */
-    Tk_Window icon;		/* Window to use as icon for this window,
-				 * or NULL. */
+    Tk_Window icon;		/* Window to use as icon for this window, or
+				 * NULL. */
     Tk_Window iconFor;		/* Window for which this window is icon, or
 				 * NULL if this isn't an icon for anyone. */
     int withdrawn;		/* Non-zero means window has been withdrawn. */
 
     /*
      * In order to support menubars transparently under X, each toplevel
-     * window is encased in an additional window, called the wrapper,
-     * that holds the toplevel and the menubar, if any.  The information
-     * below is used to keep track of the wrapper and the menubar.
+     * window is encased in an additional window, called the wrapper, that
+     * holds the toplevel and the menubar, if any. The information below is
+     * used to keep track of the wrapper and the menubar.
      */
 
     TkWindow *wrapperPtr;	/* Pointer to information about the wrapper.
-				 * This is the "real" toplevel window as
-				 * seen by the window manager. Although
-				 * this is an official Tk window, it
-				 * doesn't appear in the application's
-				 * window hierarchy.  NULL means that
-				 * the wrapper hasn't been created yet. */
-    Tk_Window menubar;		/* Pointer to information about the
-				 * menubar, or NULL if there is no
-				 * menubar for this toplevel. */
+				 * This is the "real" toplevel window as seen
+				 * by the window manager. Although this is an
+				 * official Tk window, it doesn't appear in
+				 * the application's window hierarchy. NULL
+				 * means that the wrapper hasn't been created
+				 * yet. */
+    Tk_Window menubar;		/* Pointer to information about the menubar,
+				 * or NULL if there is no menubar for this
+				 * toplevel. */
     int menuHeight;		/* Amount of vertical space needed for
-				 * menubar, measured in pixels.  If
-				 * menubar is non-NULL, this is >= 1 (X
-				 * servers don't like dimensions of 0). */
+				 * menubar, measured in pixels. If menubar is
+				 * non-NULL, this is >= 1 (X servers don't
+				 * like dimensions of 0). */
 
     /*
-     * Information used to construct an XSizeHints structure for
-     * the window manager:
+     * Information used to construct an XSizeHints structure for the window
+     * manager:
      */
 
-    int sizeHintsFlags;		/* Flags word for XSizeHints structure.
-				 * If the PBaseSize flag is set then the
-				 * window is gridded;  otherwise it isn't
-				 * gridded. */
-    int minWidth, minHeight;	/* Minimum dimensions of window, in
-				 * pixels or grid units. */
-    int maxWidth, maxHeight;	/* Maximum dimensions of window, in
-				 * pixels or grid units. 0 to default.*/
+    int sizeHintsFlags;		/* Flags word for XSizeHints structure. If the
+				 * PBaseSize flag is set then the window is
+				 * gridded; otherwise it isn't gridded. */
+    int minWidth, minHeight;	/* Minimum dimensions of window, in pixels or
+				 * grid units. */
+    int maxWidth, maxHeight;	/* Maximum dimensions of window, in pixels or
+				 * grid units. 0 to default.*/
     Tk_Window gridWin;		/* Identifies the window that controls
-				 * gridding for this top-level, or NULL if
-				 * the top-level isn't currently gridded. */
-    int widthInc, heightInc;	/* Increments for size changes (# pixels
-				 * per step). */
+				 * gridding for this top-level, or NULL if the
+				 * top-level isn't currently gridded. */
+    int widthInc, heightInc;	/* Increments for size changes (# pixels per
+				 * step). */
     struct {
-	int x;	/* numerator */
-	int y;  /* denominator */
+	int x;			/* numerator */
+	int y;			/* denominator */
     } minAspect, maxAspect;	/* Min/max aspect ratios for window. */
     int reqGridWidth, reqGridHeight;
-				/* The dimensions of the window (in
-				 * grid units) requested through
-				 * the geometry manager. */
+				/* The dimensions of the window (in grid
+				 * units) requested through the geometry
+				 * manager. */
     int gravity;		/* Desired window gravity. */
 
     /*
      * Information used to manage the size and location of a window.
      */
 
-    int width, height;		/* Desired dimensions of window, specified
-				 * in pixels or grid units.  These values are
-				 * set by the "wm geometry" command and by
-				 * ConfigureNotify events (for when wm
-				 * resizes window).  -1 means user hasn't
-				 * requested dimensions. */
+    int width, height;		/* Desired dimensions of window, specified in
+				 * pixels or grid units. These values are set
+				 * by the "wm geometry" command and by
+				 * ConfigureNotify events (for when wm resizes
+				 * window). -1 means user hasn't requested
+				 * dimensions. */
     int x, y;			/* Desired X and Y coordinates for window.
-				 * These values are set by "wm geometry",
-				 * plus by ConfigureNotify events (when wm
-				 * moves window).  These numbers are
-				 * different than the numbers stored in
-				 * winPtr->changes because (a) they could be
-				 * measured from the right or bottom edge
-				 * of the screen (see WM_NEGATIVE_X and
-				 * WM_NEGATIVE_Y flags) and (b) if the window
-				 * has been reparented then they refer to the
-				 * parent rather than the window itself. */
+				 * These values are set by "wm geometry", plus
+				 * by ConfigureNotify events (when wm moves
+				 * window). These numbers are different than
+				 * the numbers stored in winPtr->changes
+				 * because (a) they could be measured from the
+				 * right or bottom edge of the screen (see
+				 * WM_NEGATIVE_X and WM_NEGATIVE_Y flags) and
+				 * (b) if the window has been reparented then
+				 * they refer to the parent rather than the
+				 * window itself. */
     int parentWidth, parentHeight;
 				/* Width and height of reparent, in pixels
-				 * *including border*.  If window hasn't been
+				 * *including border*. If window hasn't been
 				 * reparented then these will be the outer
 				 * dimensions of the window, including
 				 * border. */
     int xInParent, yInParent;	/* Offset of wrapperPtr within reparent,
 				 * measured in pixels from upper-left outer
 				 * corner of reparent's border to upper-left
-				 * outer corner of wrapperPtr's border.  If
-				 * not reparented then these are zero. */
+				 * outer corner of wrapperPtr's border. If not
+				 * reparented then these are zero. */
     int configWidth, configHeight;
 				/* Dimensions passed to last request that we
 				 * issued to change geometry of the wrapper.
@@ -164,35 +161,34 @@ typedef struct TkWmInfo {
 				 * operations. */
 
     /*
-     * Information about the virtual root window for this top-level,
-     * if there is one.
+     * Information about the virtual root window for this top-level, if there
+     * is one.
      */
 
-    Window vRoot;		/* Virtual root window for this top-level,
-				 * or None if there is no virtual root
-				 * window (i.e. just use the screen's root). */
+    Window vRoot;		/* Virtual root window for this top-level, or
+				 * None if there is no virtual root window
+				 * (i.e. just use the screen's root). */
     int vRootX, vRootY;		/* Position of the virtual root inside the
-				 * root window.  If the WM_VROOT_OFFSET_STALE
+				 * root window. If the WM_VROOT_OFFSET_STALE
 				 * flag is set then this information may be
 				 * incorrect and needs to be refreshed from
-				 * the X server.  If vRoot is None then these
+				 * the X server. If vRoot is None then these
 				 * values are both 0. */
-    int vRootWidth, vRootHeight;/* Dimensions of the virtual root window.
-				 * If vRoot is None, gives the dimensions
-				 * of the containing screen.  This information
-				 * is never stale, even though vRootX and
-				 * vRootY can be. */
+    int vRootWidth, vRootHeight;/* Dimensions of the virtual root window. If
+				 * vRoot is None, gives the dimensions of the
+				 * containing screen. This information is
+				 * never stale, even though vRootX and vRootY
+				 * can be. */
 
     /*
      * Miscellaneous information.
      */
 
-    ProtocolHandler *protPtr;	/* First in list of protocol handlers for
-				 * this window (NULL means none). */
+    ProtocolHandler *protPtr;	/* First in list of protocol handlers for this
+				 * window (NULL means none). */
     int cmdArgc;		/* Number of elements in cmdArgv below. */
-    CONST char **cmdArgv;	/* Array of strings to store in the
-				 * WM_COMMAND property.  NULL means nothing
-				 * available. */
+    CONST char **cmdArgv;	/* Array of strings to store in the WM_COMMAND
+				 * property. NULL means nothing available. */
     char *clientMachine;	/* String to store in WM_CLIENT_MACHINE
 				 * property, or NULL. */
     int flags;			/* Miscellaneous flags, defined below. */
@@ -205,15 +201,15 @@ typedef struct TkWmInfo {
 /*
  * Flag values for WmInfo structures:
  *
- * WM_NEVER_MAPPED -		non-zero means window has never been
- *				mapped;  need to update all info when
- *				window is first mapped.
+ * WM_NEVER_MAPPED -		non-zero means window has never been mapped;
+ *				need to update all info when window is first
+ *				mapped.
  * WM_UPDATE_PENDING -		non-zero means a call to UpdateGeometryInfo
- *				has already been scheduled for this
- *				window;  no need to schedule another one.
+ *				has already been scheduled for this window;
+ *				no need to schedule another one.
  * WM_NEGATIVE_X -		non-zero means x-coordinate is measured in
- *				pixels from right edge of screen, rather
- *				than from left edge.
+ *				pixels from right edge of screen, rather than
+ *				from left edge.
  * WM_NEGATIVE_Y -		non-zero means y-coordinate is measured in
  *				pixels up from bottom of screen, rather than
  *				down from top.
@@ -224,27 +220,24 @@ typedef struct TkWmInfo {
  * WM_VROOT_OFFSET_STALE -	non-zero means that (x,y) offset information
  *				about the virtual root window is stale and
  *				needs to be fetched fresh from the X server.
- * WM_ABOUT_TO_MAP -		non-zero means that the window is about to
- *				be mapped by TkWmMapWindow.  This is used
- *				by UpdateGeometryInfo to modify its behavior.
- * WM_MOVE_PENDING -		non-zero means the application has requested
- *				a new position for the window, but it hasn't
- *				been reflected through the window manager
- *				yet.
- * WM_COLORMAPS_EXPLICIT -	non-zero means the colormap windows were
- *				set explicitly via "wm colormapwindows".
+ * WM_ABOUT_TO_MAP -		non-zero means that the window is about to be
+ *				mapped by TkWmMapWindow. This is used by
+ *				UpdateGeometryInfo to modify its behavior.
+ * WM_MOVE_PENDING -		non-zero means the application has requested a
+ *				new position for the window, but it hasn't
+ *				been reflected through the window manager yet.
+ * WM_COLORMAPS_EXPLICIT -	non-zero means the colormap windows were set
+ *				explicitly via "wm colormapwindows".
  * WM_ADDED_TOPLEVEL_COLORMAP - non-zero means that when "wm colormapwindows"
  *				was called the top-level itself wasn't
- *				specified, so we added it implicitly at
- *				the end of the list.
+ *				specified, so we added it implicitly at the
+ *				end of the list.
  * WM_WIDTH_NOT_RESIZABLE -	non-zero means that we're not supposed to
  *				allow the user to change the width of the
- *				window (controlled by "wm resizable"
- *				command).
+ *				window (controlled by "wm resizable" command).
  * WM_HEIGHT_NOT_RESIZABLE -	non-zero means that we're not supposed to
  *				allow the user to change the height of the
- *				window (controlled by "wm resizable"
- *				command).
+ *				window (controlled by "wm resizable" command).
  * WM_WITHDRAWN -		non-zero means that this window has explicitly
  *				been withdrawn. If it's a transient, it should
  *				not mirror state changes in the master.
@@ -263,12 +256,12 @@ typedef struct TkWmInfo {
 #define WM_ADDED_TOPLEVEL_COLORMAP	0x800
 #define WM_WIDTH_NOT_RESIZABLE		0x1000
 #define WM_HEIGHT_NOT_RESIZABLE		0x2000
-#define WM_WITHDRAWN		       	0x4000
+#define WM_WITHDRAWN			0x4000
 
 /*
- * This module keeps a list of all top-level windows, primarily to
- * simplify the job of Tk_CoordsToWindow.  The list is called
- * firstWmPtr and is stored in the TkDisplay structure.
+ * This module keeps a list of all top-level windows, primarily to simplify
+ * the job of Tk_CoordsToWindow. The list is called firstWmPtr and is stored
+ * in the TkDisplay structure.
  */
 
 /*
@@ -276,22 +269,18 @@ typedef struct TkWmInfo {
  * management of top-level and menubar windows.
  */
 
-static void		TopLevelReqProc _ANSI_ARGS_((ClientData dummy,
-			    Tk_Window tkwin));
+static void		TopLevelReqProc(ClientData dummy, Tk_Window tkwin);
+static void		MenubarReqProc(ClientData clientData, Tk_Window tkwin);
 
 static Tk_GeomMgr wmMgrType = {
     "wm",				/* name */
     TopLevelReqProc,			/* requestProc */
-    (Tk_GeomLostSlaveProc *) NULL,	/* lostSlaveProc */
+    NULL,				/* lostSlaveProc */
 };
-
-static void		MenubarReqProc _ANSI_ARGS_((ClientData clientData,
-			    Tk_Window tkwin));
-
 static Tk_GeomMgr menubarMgrType = {
     "menubar",				/* name */
     MenubarReqProc,			/* requestProc */
-    (Tk_GeomLostSlaveProc *) NULL,	/* lostSlaveProc */
+    NULL,				/* lostSlaveProc */
 };
 
 /*
@@ -304,156 +293,147 @@ typedef struct WaitRestrictInfo {
     WmInfo *wmInfoPtr;
     int type;			/* We only care about this type of event. */
     XEvent *eventPtr;		/* Where to store the event when it's found. */
-    int foundEvent;		/* Non-zero means that an event of the
-				 * desired type has been found. */
+    int foundEvent;		/* Non-zero means that an event of the desired
+				 * type has been found. */
 } WaitRestrictInfo;
 
 /*
- * Forward declarations for procedures defined in this file:
+ * Forward declarations for functions defined in this file:
  */
 
-static int		ComputeReparentGeometry _ANSI_ARGS_((WmInfo *wmPtr));
-static void		ConfigureEvent _ANSI_ARGS_((WmInfo *wmPtr,
-			    XConfigureEvent *eventPtr));
-static void		CreateWrapper _ANSI_ARGS_((WmInfo *wmPtr));
-static void		GetMaxSize _ANSI_ARGS_((WmInfo *wmPtr,
-			    int *maxWidthPtr, int *maxHeightPtr));
-static void		MenubarDestroyProc _ANSI_ARGS_((ClientData clientData,
-			    XEvent *eventPtr));
-static int		ParseGeometry _ANSI_ARGS_((Tcl_Interp *interp,
-			    char *string, TkWindow *winPtr));
-static void		ReparentEvent _ANSI_ARGS_((WmInfo *wmPtr,
-			    XReparentEvent *eventPtr));
-static void		TkWmStackorderToplevelWrapperMap _ANSI_ARGS_((
-			    TkWindow *winPtr,
-			    Display *display,
-			    Tcl_HashTable *reparentTable));
-static void		TopLevelReqProc _ANSI_ARGS_((ClientData dummy,
-			    Tk_Window tkwin));
-static void		UpdateCommand _ANSI_ARGS_((TkWindow *winPtr));
-static void		UpdateGeometryInfo _ANSI_ARGS_((
-			    ClientData clientData));
-static void		UpdateHints _ANSI_ARGS_((TkWindow *winPtr));
-static void		UpdateSizeHints _ANSI_ARGS_((TkWindow *winPtr,
-			    int newWidth, int newHeight));
-static void		UpdateTitle _ANSI_ARGS_((TkWindow *winPtr));
-static void		UpdatePhotoIcon _ANSI_ARGS_((TkWindow *winPtr));
-static void		UpdateVRootGeometry _ANSI_ARGS_((WmInfo *wmPtr));
-static void		UpdateWmProtocols _ANSI_ARGS_((WmInfo *wmPtr));
-static void		WaitForConfigureNotify _ANSI_ARGS_((TkWindow *winPtr,
-			    unsigned long serial));
-static int		WaitForEvent _ANSI_ARGS_((Display *display,
-			    WmInfo *wmInfoPtr, int type, XEvent *eventPtr));
-static void		WaitForMapNotify _ANSI_ARGS_((TkWindow *winPtr,
-			    int mapped));
+static int		ComputeReparentGeometry(WmInfo *wmPtr);
+static void		ConfigureEvent(WmInfo *wmPtr,
+			    XConfigureEvent *eventPtr);
+static void		CreateWrapper(WmInfo *wmPtr);
+static void		GetMaxSize(WmInfo *wmPtr, int *maxWidthPtr,
+			    int *maxHeightPtr);
+static void		MenubarDestroyProc(ClientData clientData,
+			    XEvent *eventPtr);
+static int		ParseGeometry(Tcl_Interp *interp, char *string,
+			    TkWindow *winPtr);
+static void		ReparentEvent(WmInfo *wmPtr, XReparentEvent *eventPtr);
+static void		TkWmStackorderToplevelWrapperMap(TkWindow *winPtr,
+			    Display *display, Tcl_HashTable *reparentTable);
+static void		TopLevelReqProc(ClientData dummy, Tk_Window tkwin);
+static void		UpdateCommand(TkWindow *winPtr);
+static void		UpdateGeometryInfo(ClientData clientData);
+static void		UpdateHints(TkWindow *winPtr);
+static void		UpdateSizeHints(TkWindow *winPtr,
+			    int newWidth, int newHeight);
+static void		UpdateTitle(TkWindow *winPtr);
+static void		UpdatePhotoIcon(TkWindow *winPtr);
+static void		UpdateVRootGeometry(WmInfo *wmPtr);
+static void		UpdateWmProtocols(WmInfo *wmPtr);
+static void		WaitForConfigureNotify(TkWindow *winPtr,
+			    unsigned long serial);
+static int		WaitForEvent(Display *display,
+			    WmInfo *wmInfoPtr, int type, XEvent *eventPtr);
+static void		WaitForMapNotify(TkWindow *winPtr, int mapped);
 static Tk_RestrictAction
-			WaitRestrictProc _ANSI_ARGS_((ClientData clientData,
-			    XEvent *eventPtr));
-static void		WrapperEventProc _ANSI_ARGS_((ClientData clientData,
-			    XEvent *eventPtr));
-static void		WmWaitMapProc _ANSI_ARGS_((
-			    ClientData clientData, XEvent *eventPtr));
-
-static int 		WmAspectCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmAttributesCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmClientCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmColormapwindowsCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmCommandCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmDeiconifyCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmFocusmodelCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmFrameCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmGeometryCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmGridCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmGroupCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmIconbitmapCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmIconifyCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmIconmaskCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmIconnameCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmIconphotoCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmIconpositionCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmIconwindowCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmMaxsizeCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmMinsizeCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmOverrideredirectCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmPositionfromCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmProtocolCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmResizableCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmSizefromCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmStackorderCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmStateCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmTitleCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmTransientCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static int 		WmWithdrawCmd _ANSI_ARGS_((Tk_Window tkwin,
-			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
-static void		WmUpdateGeom _ANSI_ARGS_((WmInfo *wmPtr,
-			    TkWindow *winPtr));
+			WaitRestrictProc(ClientData clientData,
+			    XEvent *eventPtr);
+static void		WrapperEventProc(ClientData clientData,
+			    XEvent *eventPtr);
+static void		WmWaitMapProc(ClientData clientData, XEvent *eventPtr);
+static int		WmAspectCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmAttributesCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmClientCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmColormapwindowsCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmCommandCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmDeiconifyCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmFocusmodelCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmFrameCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmGeometryCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmGridCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmGroupCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmIconbitmapCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmIconifyCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmIconmaskCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmIconnameCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmIconphotoCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmIconpositionCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmIconwindowCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmMaxsizeCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmMinsizeCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmOverrideredirectCmd(Tk_Window tkwin,TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmPositionfromCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmProtocolCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmResizableCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmSizefromCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmStackorderCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmStateCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmTitleCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmTransientCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static int		WmWithdrawCmd(Tk_Window tkwin, TkWindow *winPtr,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *CONST objv[]);
+static void		WmUpdateGeom(WmInfo *wmPtr, TkWindow *winPtr);
 
 /*
  *--------------------------------------------------------------
  *
  * TkWmCleanup --
  *
- *	This procedure is invoked to cleanup remaining wm resources
- *	associated with a display.
+ *	This function is invoked to cleanup remaining wm resources associated
+ *	with a display.
  *
  * Results:
  *	None.
@@ -464,15 +444,17 @@ static void		WmUpdateGeom _ANSI_ARGS_((WmInfo *wmPtr,
  *--------------------------------------------------------------
  */
 
-void TkWmCleanup(dispPtr)
-    TkDisplay *dispPtr;
+void TkWmCleanup(
+    TkDisplay *dispPtr)
 {
     WmInfo *wmPtr, *nextPtr;
+
     for (wmPtr = dispPtr->firstWmPtr; wmPtr != NULL; wmPtr = nextPtr) {
 	/*
-	 * We can't assume we have access to winPtr's anymore, so some
-	 * cleanup requiring winPtr data is avoided.
+	 * We can't assume we have access to winPtr's anymore, so some cleanup
+	 * requiring winPtr data is avoided.
 	 */
+
 	nextPtr = wmPtr->nextPtr;
 	if (wmPtr->title != NULL) {
 	    ckfree(wmPtr->title);
@@ -518,9 +500,8 @@ void TkWmCleanup(dispPtr)
  *
  * TkWmNewWindow --
  *
- *	This procedure is invoked whenever a new top-level
- *	window is created.  Its job is to initialize the WmInfo
- *	structure for the window.
+ *	This function is invoked whenever a new top-level window is created.
+ *	Its job is to initialize the WmInfo structure for the window.
  *
  * Results:
  *	None.
@@ -532,8 +513,8 @@ void TkWmCleanup(dispPtr)
  */
 
 void
-TkWmNewWindow(winPtr)
-    TkWindow *winPtr;		/* Newly-created top-level window. */
+TkWmNewWindow(
+    TkWindow *winPtr)		/* Newly-created top-level window. */
 {
     register WmInfo *wmPtr;
     TkDisplay *dispPtr = winPtr->dispPtr;
@@ -554,8 +535,8 @@ TkWmNewWindow(winPtr)
     wmPtr->hints.window_group = None;
 
     /*
-     * Default the maximum dimensions to the size of the display, minus
-     * a guess about how space is needed for window manager decorations.
+     * Default the maximum dimensions to the size of the display, minus a
+     * guess about how space is needed for window manager decorations.
      */
 
     wmPtr->gridWin = NULL;
@@ -585,8 +566,8 @@ TkWmNewWindow(winPtr)
     UpdateVRootGeometry(wmPtr);
 
     /*
-     * Arrange for geometry requests to be reflected from the window
-     * to the window manager.
+     * Arrange for geometry requests to be reflected from the window to the
+     * window manager.
      */
 
     Tk_ManageGeometry((Tk_Window) winPtr, &wmMgrType, (ClientData) 0);
@@ -597,28 +578,28 @@ TkWmNewWindow(winPtr)
  *
  * TkWmMapWindow --
  *
- *	This procedure is invoked to map a top-level window.  This
- *	module gets a chance to update all window-manager-related
- *	information in properties before the window manager sees
- *	the map event and checks the properties.  It also gets to
- *	decide whether or not to even map the window after all.
+ *	This function is invoked to map a top-level window. This module gets a
+ *	chance to update all window-manager-related information in properties
+ *	before the window manager sees the map event and checks the
+ *	properties. It also gets to decide whether or not to even map the
+ *	window after all.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Properties of winPtr may get updated to provide up-to-date
- *	information to the window manager.  The window may also get
- *	mapped, but it may not be if this procedure decides that
- *	isn't appropriate (e.g. because the window is withdrawn).
+ *	Properties of winPtr may get updated to provide up-to-date information
+ *	to the window manager. The window may also get mapped, but it may not
+ *	be if this function decides that isn't appropriate (e.g. because the
+ *	window is withdrawn).
  *
  *--------------------------------------------------------------
  */
 
 void
-TkWmMapWindow(winPtr)
-    TkWindow *winPtr;		/* Top-level window that's about to
-				 * be mapped. */
+TkWmMapWindow(
+    TkWindow *winPtr)		/* Top-level window that's about to be
+				 * mapped. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     XTextProperty textProp;
@@ -629,9 +610,8 @@ TkWmMapWindow(winPtr)
 	wmPtr->flags &= ~WM_NEVER_MAPPED;
 
 	/*
-	 * This is the first time this window has ever been mapped.
-	 * First create the wrapper window that provides space for a
-	 * menubar.
+	 * This is the first time this window has ever been mapped. First
+	 * create the wrapper window that provides space for a menubar.
 	 */
 
 	if (wmPtr->wrapperPtr == NULL) {
@@ -639,8 +619,7 @@ TkWmMapWindow(winPtr)
 	}
 
 	/*
-	 * Store all the window-manager-related information for the
-	 * window.
+	 * Store all the window-manager-related information for the window.
 	 */
 
 	TkWmSetClass(winPtr);
@@ -653,11 +632,12 @@ TkWmMapWindow(winPtr)
 	     */
 
 	    if (!Tk_IsMapped(wmPtr->masterPtr)) {
-	        wmPtr->withdrawn = 1;
-	        wmPtr->hints.initial_state = WithdrawnState;
+		wmPtr->withdrawn = 1;
+		wmPtr->hints.initial_state = WithdrawnState;
 	    } else {
-	        XSetTransientForHint(winPtr->display, wmPtr->wrapperPtr->window,
-		        wmPtr->masterPtr->wmInfoPtr->wrapperPtr->window);
+		XSetTransientForHint(winPtr->display,
+			wmPtr->wrapperPtr->window,
+			wmPtr->masterPtr->wmInfoPtr->wrapperPtr->window);
 	    }
 	}
 
@@ -683,9 +663,8 @@ TkWmMapWindow(winPtr)
     }
     if (wmPtr->iconFor != NULL) {
 	/*
-	 * This window is an icon for somebody else.  Make sure that
-	 * the geometry is up-to-date, then return without mapping
-	 * the window.
+	 * This window is an icon for somebody else. Make sure that the
+	 * geometry is up-to-date, then return without mapping the window.
 	 */
 
 	if (wmPtr->flags & WM_UPDATE_PENDING) {
@@ -717,9 +696,8 @@ TkWmMapWindow(winPtr)
  *
  * TkWmUnmapWindow --
  *
- *	This procedure is invoked to unmap a top-level window.  The
- *	only thing it does special is to wait for the window actually
- *	to be unmapped.
+ *	This function is invoked to unmap a top-level window. The only thing
+ *	it does special is to wait for the window actually to be unmapped.
  *
  * Results:
  *	None.
@@ -731,20 +709,20 @@ TkWmMapWindow(winPtr)
  */
 
 void
-TkWmUnmapWindow(winPtr)
-    TkWindow *winPtr;		/* Top-level window that's about to
-				 * be mapped. */
+TkWmUnmapWindow(
+    TkWindow *winPtr)		/* Top-level window that's about to be
+				 * mapped. */
 {
     /*
-     * It seems to be important to wait after unmapping a top-level
-     * window until the window really gets unmapped.  I don't completely
-     * understand all the interactions with the window manager, but if
-     * we go on without waiting, and if the window is then mapped again
-     * quickly, events seem to get lost so that we think the window isn't
-     * mapped when in fact it is mapped.  I suspect that this has something
-     * to do with the window manager filtering Map events (and possily not
-     * filtering Unmap events?).
+     * It seems to be important to wait after unmapping a top-level window
+     * until the window really gets unmapped. I don't completely understand
+     * all the interactions with the window manager, but if we go on without
+     * waiting, and if the window is then mapped again quickly, events seem to
+     * get lost so that we think the window isn't mapped when in fact it is
+     * mapped. I suspect that this has something to do with the window manager
+     * filtering Map events (and possily not filtering Unmap events?).
      */
+
     XUnmapWindow(winPtr->display, winPtr->wmInfoPtr->wrapperPtr->window);
     WaitForMapNotify(winPtr, 0);
 }
@@ -754,9 +732,8 @@ TkWmUnmapWindow(winPtr)
  *
  * TkWmDeadWindow --
  *
- *	This procedure is invoked when a top-level window is
- *	about to be deleted.  It cleans up the wm-related data
- *	structures for the window.
+ *	This function is invoked when a top-level window is about to be
+ *	deleted. It cleans up the wm-related data structures for the window.
  *
  * Results:
  *	None.
@@ -768,8 +745,8 @@ TkWmUnmapWindow(winPtr)
  */
 
 void
-TkWmDeadWindow(winPtr)
-    TkWindow *winPtr;		/* Top-level window that's being deleted. */
+TkWmDeadWindow(
+    TkWindow *winPtr)		/* Top-level window that's being deleted. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     WmInfo *wmPtr2;
@@ -783,7 +760,7 @@ TkWmDeadWindow(winPtr)
 	register WmInfo *prevPtr;
 
 	for (prevPtr = (WmInfo *) winPtr->dispPtr->firstWmPtr; ;
-                prevPtr = prevPtr->nextPtr) {
+		prevPtr = prevPtr->nextPtr) {
 	    if (prevPtr == NULL) {
 		Tcl_Panic("couldn't unlink window in TkWmDeadWindow");
 	    }
@@ -827,10 +804,10 @@ TkWmDeadWindow(winPtr)
     }
     if (wmPtr->wrapperPtr != NULL) {
 	/*
-	 * The rest of Tk doesn't know that we reparent the toplevel
-	 * inside the wrapper, so reparent it back out again before
-	 * deleting the wrapper; otherwise the toplevel will get deleted
-	 * twice (once implicitly by the deletion of the wrapper).
+	 * The rest of Tk doesn't know that we reparent the toplevel inside
+	 * the wrapper, so reparent it back out again before deleting the
+	 * wrapper; otherwise the toplevel will get deleted twice (once
+	 * implicitly by the deletion of the wrapper).
 	 */
 
 	XUnmapWindow(winPtr->display, winPtr->window);
@@ -854,42 +831,47 @@ TkWmDeadWindow(winPtr)
     if (wmPtr->flags & WM_UPDATE_PENDING) {
 	Tcl_CancelIdleCall(UpdateGeometryInfo, (ClientData) winPtr);
     }
+
     /*
      * Reset all transient windows whose master is the dead window.
      */
 
     for (wmPtr2 = winPtr->dispPtr->firstWmPtr; wmPtr2 != NULL;
-	 wmPtr2 = wmPtr2->nextPtr) {
+	    wmPtr2 = wmPtr2->nextPtr) {
 	if (wmPtr2->masterPtr == winPtr) {
 	    wmPtr->numTransients--;
 	    Tk_DeleteEventHandler((Tk_Window) wmPtr2->masterPtr,
-	            StructureNotifyMask,
-	            WmWaitMapProc, (ClientData) wmPtr2->winPtr);
+		    StructureNotifyMask,
+		    WmWaitMapProc, (ClientData) wmPtr2->winPtr);
 	    wmPtr2->masterPtr = NULL;
 	    if (!(wmPtr2->flags & WM_NEVER_MAPPED)) {
 		XDeleteProperty(winPtr->display, wmPtr2->wrapperPtr->window,
 			Tk_InternAtom((Tk_Window) winPtr, "WM_TRANSIENT_FOR"));
-		/* FIXME: Need a call like Win32's UpdateWrapper() so
-		   we can recreate the wrapper and get rid of the
-		   transient window decorations. */
+
+		/*
+		 * FIXME: Need a call like Win32's UpdateWrapper() so we can
+		 * recreate the wrapper and get rid of the transient window
+		 * decorations.
+		 */
 	    }
 	}
     }
-    if (wmPtr->numTransients != 0)
-        Tcl_Panic("numTransients should be 0");
+    if (wmPtr->numTransients != 0) {
+	Tcl_Panic("numTransients should be 0");
+    }
 
     if (wmPtr->masterPtr != NULL) {
 	wmPtr2 = wmPtr->masterPtr->wmInfoPtr;
+
 	/*
-	 * If we had a master, tell them that we aren't tied
-	 * to them anymore
+	 * If we had a master, tell them that we aren't tied to them anymore
 	 */
+
 	if (wmPtr2 != NULL) {
 	    wmPtr2->numTransients--;
 	}
 	Tk_DeleteEventHandler((Tk_Window) wmPtr->masterPtr,
-		StructureNotifyMask,
-		WmWaitMapProc, (ClientData) winPtr);
+		StructureNotifyMask, WmWaitMapProc, (ClientData) winPtr);
 	wmPtr->masterPtr = NULL;
     }
     ckfree((char *) wmPtr);
@@ -901,11 +883,10 @@ TkWmDeadWindow(winPtr)
  *
  * TkWmSetClass --
  *
- *	This procedure is invoked whenever a top-level window's
- *	class is changed.  If the window has been mapped then this
- *	procedure updates the window manager property for the
- *	class.  If the window hasn't been mapped, the update is
- *	deferred until just before the first mapping.
+ *	This function is invoked whenever a top-level window's class is
+ *	changed. If the window has been mapped then this function updates the
+ *	window manager property for the class. If the window hasn't been
+ *	mapped, the update is deferred until just before the first mapping.
  *
  * Results:
  *	None.
@@ -917,8 +898,8 @@ TkWmDeadWindow(winPtr)
  */
 
 void
-TkWmSetClass(winPtr)
-    TkWindow *winPtr;		/* Newly-created top-level window. */
+TkWmSetClass(
+    TkWindow *winPtr)		/* Newly-created top-level window. */
 {
     if (winPtr->wmInfoPtr->flags & WM_NEVER_MAPPED) {
 	return;
@@ -946,8 +927,8 @@ TkWmSetClass(winPtr)
  *
  * Tk_WmObjCmd --
  *
- *	This procedure is invoked to process the "wm" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm" Tcl command. See the user
+ *	documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -960,12 +941,11 @@ TkWmSetClass(winPtr)
 
 	/* ARGSUSED */
 int
-Tk_WmObjCmd(clientData, interp, objc, objv)
-    ClientData clientData;	/* Main window associated with
-				 * interpreter. */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+Tk_WmObjCmd(
+    ClientData clientData,	/* Main window associated with interpreter. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     Tk_Window tkwin = (Tk_Window) clientData;
     static CONST char *optionStrings[] = {
@@ -975,27 +955,27 @@ Tk_WmObjCmd(clientData, interp, objc, objv)
 	"iconify", "iconmask", "iconname",
 	"iconphoto", "iconposition",
 	"iconwindow", "maxsize", "minsize", "overrideredirect",
-        "positionfrom", "protocol", "resizable", "sizefrom",
-        "stackorder", "state", "title", "transient",
-	"withdraw", (char *) NULL };
+	"positionfrom", "protocol", "resizable", "sizefrom",
+	"stackorder", "state", "title", "transient",
+	"withdraw", NULL };
     enum options {
-        WMOPT_ASPECT, WMOPT_ATTRIBUTES, WMOPT_CLIENT, WMOPT_COLORMAPWINDOWS,
+	WMOPT_ASPECT, WMOPT_ATTRIBUTES, WMOPT_CLIENT, WMOPT_COLORMAPWINDOWS,
 	WMOPT_COMMAND, WMOPT_DEICONIFY, WMOPT_FOCUSMODEL, WMOPT_FRAME,
 	WMOPT_GEOMETRY, WMOPT_GRID, WMOPT_GROUP, WMOPT_ICONBITMAP,
 	WMOPT_ICONIFY, WMOPT_ICONMASK, WMOPT_ICONNAME,
 	WMOPT_ICONPHOTO, WMOPT_ICONPOSITION,
 	WMOPT_ICONWINDOW, WMOPT_MAXSIZE, WMOPT_MINSIZE, WMOPT_OVERRIDEREDIRECT,
-        WMOPT_POSITIONFROM, WMOPT_PROTOCOL, WMOPT_RESIZABLE, WMOPT_SIZEFROM,
-        WMOPT_STACKORDER, WMOPT_STATE, WMOPT_TITLE, WMOPT_TRANSIENT,
+	WMOPT_POSITIONFROM, WMOPT_PROTOCOL, WMOPT_RESIZABLE, WMOPT_SIZEFROM,
+	WMOPT_STACKORDER, WMOPT_STATE, WMOPT_TITLE, WMOPT_TRANSIENT,
 	WMOPT_WITHDRAW };
-    int index; 
+    int index;
     int length;
     char *argv1;
     TkWindow *winPtr;
     TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
 
     if (objc < 2) {
-	wrongNumArgs:
+    wrongNumArgs:
 	Tcl_WrongNumArgs(interp, 1, objv, "option window ?arg ...?");
 	return TCL_ERROR;
     }
@@ -1040,70 +1020,70 @@ Tk_WmObjCmd(clientData, interp, objc, objv)
     }
     if (!Tk_IsTopLevel(winPtr)) {
 	Tcl_AppendResult(interp, "window \"", winPtr->pathName,
-		"\" isn't a top-level window", (char *) NULL);
+		"\" isn't a top-level window", NULL);
 	return TCL_ERROR;
     }
 
     switch ((enum options) index) {
-      case WMOPT_ASPECT:
+    case WMOPT_ASPECT:
 	return WmAspectCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_ATTRIBUTES:
+    case WMOPT_ATTRIBUTES:
 	return WmAttributesCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_CLIENT:
+    case WMOPT_CLIENT:
 	return WmClientCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_COLORMAPWINDOWS:
+    case WMOPT_COLORMAPWINDOWS:
 	return WmColormapwindowsCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_COMMAND:
+    case WMOPT_COMMAND:
 	return WmCommandCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_DEICONIFY:
+    case WMOPT_DEICONIFY:
 	return WmDeiconifyCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_FOCUSMODEL:
+    case WMOPT_FOCUSMODEL:
 	return WmFocusmodelCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_FRAME:
+    case WMOPT_FRAME:
 	return WmFrameCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_GEOMETRY:
+    case WMOPT_GEOMETRY:
 	return WmGeometryCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_GRID:
+    case WMOPT_GRID:
 	return WmGridCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_GROUP:
+    case WMOPT_GROUP:
 	return WmGroupCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_ICONBITMAP:
+    case WMOPT_ICONBITMAP:
 	return WmIconbitmapCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_ICONIFY:
+    case WMOPT_ICONIFY:
 	return WmIconifyCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_ICONMASK:
+    case WMOPT_ICONMASK:
 	return WmIconmaskCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_ICONNAME:
+    case WMOPT_ICONNAME:
 	return WmIconnameCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_ICONPHOTO:
-        return WmIconphotoCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_ICONPOSITION:
+    case WMOPT_ICONPHOTO:
+	return WmIconphotoCmd(tkwin, winPtr, interp, objc, objv);
+    case WMOPT_ICONPOSITION:
 	return WmIconpositionCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_ICONWINDOW:
+    case WMOPT_ICONWINDOW:
 	return WmIconwindowCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_MAXSIZE:
+    case WMOPT_MAXSIZE:
 	return WmMaxsizeCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_MINSIZE:
+    case WMOPT_MINSIZE:
 	return WmMinsizeCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_OVERRIDEREDIRECT:
+    case WMOPT_OVERRIDEREDIRECT:
 	return WmOverrideredirectCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_POSITIONFROM:
+    case WMOPT_POSITIONFROM:
 	return WmPositionfromCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_PROTOCOL:
+    case WMOPT_PROTOCOL:
 	return WmProtocolCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_RESIZABLE:
+    case WMOPT_RESIZABLE:
 	return WmResizableCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_SIZEFROM:
+    case WMOPT_SIZEFROM:
 	return WmSizefromCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_STACKORDER:
+    case WMOPT_STACKORDER:
 	return WmStackorderCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_STATE:
+    case WMOPT_STATE:
 	return WmStateCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_TITLE:
+    case WMOPT_TITLE:
 	return WmTitleCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_TRANSIENT:
+    case WMOPT_TRANSIENT:
 	return WmTransientCmd(tkwin, winPtr, interp, objc, objv);
-      case WMOPT_WITHDRAW:
+    case WMOPT_WITHDRAW:
 	return WmWithdrawCmd(tkwin, winPtr, interp, objc, objv);
     }
 
@@ -1116,8 +1096,8 @@ Tk_WmObjCmd(clientData, interp, objc, objv)
  *
  * WmAspectCmd --
  *
- *	This procedure is invoked to process the "wm aspect" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm aspect" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -1129,12 +1109,12 @@ Tk_WmObjCmd(clientData, interp, objc, objv)
  */
 
 static int
-WmAspectCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmAspectCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     int numer1, denom1, numer2, denom2;
@@ -1186,7 +1166,7 @@ WmAspectCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmAttributesCmd --
  *
- *	This procedure is invoked to process the "wm attributes" Tcl command.
+ *	This function is invoked to process the "wm attributes" Tcl command.
  *	See the user documentation for details on what it does.
  *
  * Results:
@@ -1199,12 +1179,12 @@ WmAspectCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmAttributesCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmAttributesCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     if (objc != 3) {
 	Tcl_WrongNumArgs(interp, 2, objv, "window");
@@ -1218,8 +1198,8 @@ WmAttributesCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmClientCmd --
  *
- *	This procedure is invoked to process the "wm client" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm client" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -1231,12 +1211,12 @@ WmAttributesCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmClientCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmClientCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     char *argv3;
@@ -1259,8 +1239,7 @@ WmClientCmd(tkwin, winPtr, interp, objc, objv)
 	    wmPtr->clientMachine = NULL;
 	    if (!(wmPtr->flags & WM_NEVER_MAPPED)) {
 		XDeleteProperty(winPtr->display, wmPtr->wrapperPtr->window,
-			Tk_InternAtom((Tk_Window) winPtr,
-				"WM_CLIENT_MACHINE"));
+			Tk_InternAtom((Tk_Window)winPtr, "WM_CLIENT_MACHINE"));
 	    }
 	}
 	return TCL_OK;
@@ -1292,9 +1271,8 @@ WmClientCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmColormapwindowsCmd --
  *
- *	This procedure is invoked to process the "wm colormapwindows"
- *	Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm colormapwindows" Tcl
+ *	command. See the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -1306,12 +1284,12 @@ WmClientCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmColormapwindowsCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmColormapwindowsCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     Window *cmapList;
@@ -1338,7 +1316,7 @@ WmColormapwindowsCmd(tkwin, winPtr, interp, objc, objv)
 		    && (wmPtr->flags & WM_ADDED_TOPLEVEL_COLORMAP)) {
 		break;
 	    }
-	    winPtr2  = (TkWindow *) Tk_IdToWindow(winPtr->display,
+	    winPtr2 = (TkWindow *) Tk_IdToWindow(winPtr->display,
 		    cmapList[i]);
 	    if (winPtr2 == NULL) {
 		sprintf(buffer, "0x%lx", cmapList[i]);
@@ -1359,8 +1337,7 @@ WmColormapwindowsCmd(tkwin, winPtr, interp, objc, objv)
     gotToplevel = 0;
     for (i = 0; i < windowObjc; i++) {
 	if (TkGetWindowFromObj(interp, tkwin, windowObjv[i],
-		(Tk_Window *) &winPtr2) != TCL_OK)
-	{
+		(Tk_Window *) &winPtr2) != TCL_OK) {
 	    ckfree((char *) cmapList);
 	    return TCL_ERROR;
 	}
@@ -1391,8 +1368,8 @@ WmColormapwindowsCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmCommandCmd --
  *
- *	This procedure is invoked to process the "wm command" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm command" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -1404,12 +1381,12 @@ WmColormapwindowsCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmCommandCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmCommandCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     char *argv3;
@@ -1459,7 +1436,7 @@ WmCommandCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmDeiconifyCmd --
  *
- *	This procedure is invoked to process the "wm deiconify" Tcl command.
+ *	This function is invoked to process the "wm deiconify" Tcl command.
  *	See the user documentation for details on what it does.
  *
  * Results:
@@ -1472,12 +1449,12 @@ WmCommandCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmDeiconifyCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmDeiconifyCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
 
@@ -1487,13 +1464,12 @@ WmDeiconifyCmd(tkwin, winPtr, interp, objc, objv)
     }
     if (wmPtr->iconFor != NULL) {
 	Tcl_AppendResult(interp, "can't deiconify ", Tcl_GetString(objv[2]),
-		": it is an icon for ", Tk_PathName(wmPtr->iconFor),
-		(char *) NULL);
+		": it is an icon for ", Tk_PathName(wmPtr->iconFor), NULL);
 	return TCL_ERROR;
     }
     if (winPtr->flags & TK_EMBEDDED) {
 	Tcl_AppendResult(interp, "can't deiconify ", winPtr->pathName,
-		": it is an embedded window", (char *) NULL);
+		": it is an embedded window", NULL);
 	return TCL_ERROR;
     }
     wmPtr->flags &= ~WM_WITHDRAWN;
@@ -1506,7 +1482,7 @@ WmDeiconifyCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmFocusmodelCmd --
  *
- *	This procedure is invoked to process the "wm focusmodel" Tcl command.
+ *	This function is invoked to process the "wm focusmodel" Tcl command.
  *	See the user documentation for details on what it does.
  *
  * Results:
@@ -1519,16 +1495,16 @@ WmDeiconifyCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmFocusmodelCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmFocusmodelCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     static CONST char *optionStrings[] = {
-	"active", "passive", (char *) NULL };
+	"active", "passive", NULL };
     enum options {
 	OPT_ACTIVE, OPT_PASSIVE };
     int index;
@@ -1561,8 +1537,8 @@ WmFocusmodelCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmFrameCmd --
  *
- *	This procedure is invoked to process the "wm frame" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm frame" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -1574,12 +1550,12 @@ WmFocusmodelCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmFrameCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmFrameCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     Window window;
@@ -1603,7 +1579,7 @@ WmFrameCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmGeometryCmd --
  *
- *	This procedure is invoked to process the "wm geometry" Tcl command.
+ *	This function is invoked to process the "wm geometry" Tcl command.
  *	See the user documentation for details on what it does.
  *
  * Results:
@@ -1616,12 +1592,12 @@ WmFrameCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmGeometryCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmGeometryCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     char xSign, ySign;
@@ -1666,8 +1642,8 @@ WmGeometryCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmGridCmd --
  *
- *	This procedure is invoked to process the "wm grid" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm grid" Tcl command. See the
+ *	user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -1679,12 +1655,12 @@ WmGeometryCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmGridCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmGridCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     int reqWidth, reqHeight, widthInc, heightInc;
@@ -1707,8 +1683,8 @@ WmGridCmd(tkwin, winPtr, interp, objc, objv)
     }
     if (*Tcl_GetString(objv[3]) == '\0') {
 	/*
-	 * Turn off gridding and reset the width and height
-	 * to make sense as ungridded numbers.
+	 * Turn off gridding and reset the width and height to make sense as
+	 * ungridded numbers.
 	 */
 
 	wmPtr->sizeHintsFlags &= ~(PBaseSize|PResizeInc);
@@ -1724,7 +1700,7 @@ WmGridCmd(tkwin, winPtr, interp, objc, objv)
 	if ((Tcl_GetIntFromObj(interp, objv[3], &reqWidth) != TCL_OK)
 		|| (Tcl_GetIntFromObj(interp, objv[4], &reqHeight) != TCL_OK)
 		|| (Tcl_GetIntFromObj(interp, objv[5], &widthInc) != TCL_OK)
-		|| (Tcl_GetIntFromObj(interp, objv[6], &heightInc) != TCL_OK)) {
+		|| (Tcl_GetIntFromObj(interp, objv[6], &heightInc) !=TCL_OK)) {
 	    return TCL_ERROR;
 	}
 	if (reqWidth < 0) {
@@ -1756,8 +1732,8 @@ WmGridCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmGroupCmd --
  *
- *	This procedure is invoked to process the "wm group" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm group" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -1769,12 +1745,12 @@ WmGridCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmGroupCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmGroupCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     Tk_Window tkwin2;
@@ -1832,7 +1808,7 @@ WmGroupCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmIconbitmapCmd --
  *
- *	This procedure is invoked to process the "wm iconbitmap" Tcl command.
+ *	This function is invoked to process the "wm iconbitmap" Tcl command.
  *	See the user documentation for details on what it does.
  *
  * Results:
@@ -1845,12 +1821,12 @@ WmGroupCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmIconbitmapCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmIconbitmapCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     Pixmap pixmap;
@@ -1892,8 +1868,8 @@ WmIconbitmapCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmIconifyCmd --
  *
- *	This procedure is invoked to process the "wm iconify" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm iconify" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -1905,12 +1881,12 @@ WmIconbitmapCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmIconifyCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmIconifyCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     if (objc != 3) {
@@ -1919,23 +1895,22 @@ WmIconifyCmd(tkwin, winPtr, interp, objc, objv)
     }
     if (Tk_Attributes((Tk_Window) winPtr)->override_redirect) {
 	Tcl_AppendResult(interp, "can't iconify \"", winPtr->pathName,
-		"\": override-redirect flag is set", (char *) NULL);
+		"\": override-redirect flag is set", NULL);
 	return TCL_ERROR;
     }
     if (wmPtr->masterPtr != NULL) {
 	Tcl_AppendResult(interp, "can't iconify \"", winPtr->pathName,
-		"\": it is a transient", (char *) NULL);
+		"\": it is a transient", NULL);
 	return TCL_ERROR;
     }
     if (wmPtr->iconFor != NULL) {
 	Tcl_AppendResult(interp, "can't iconify ", winPtr->pathName,
-		": it is an icon for ", Tk_PathName(wmPtr->iconFor),
-		(char *) NULL);
+		": it is an icon for ", Tk_PathName(wmPtr->iconFor), NULL);
 	return TCL_ERROR;
     }
     if (winPtr->flags & TK_EMBEDDED) {
 	Tcl_AppendResult(interp, "can't iconify ", winPtr->pathName,
-		": it is an embedded window", (char *) NULL);
+		": it is an embedded window", NULL);
 	return TCL_ERROR;
     }
     if (TkpWmSetState(winPtr, IconicState) == 0) {
@@ -1952,7 +1927,7 @@ WmIconifyCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmIconmaskCmd --
  *
- *	This procedure is invoked to process the "wm iconmask" Tcl command.
+ *	This function is invoked to process the "wm iconmask" Tcl command.
  *	See the user documentation for details on what it does.
  *
  * Results:
@@ -1965,12 +1940,12 @@ WmIconifyCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmIconmaskCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmIconmaskCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     Pixmap pixmap;
@@ -2011,7 +1986,7 @@ WmIconmaskCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmIconnameCmd --
  *
- *	This procedure is invoked to process the "wm iconname" Tcl command.
+ *	This function is invoked to process the "wm iconname" Tcl command.
  *	See the user documentation for details on what it does.
  *
  * Results:
@@ -2024,12 +1999,12 @@ WmIconmaskCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmIconnameCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmIconnameCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     char *argv3;
@@ -2063,8 +2038,7 @@ WmIconnameCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmIconphotoCmd --
  *
- *	This procedure is invoked to process the "wm iconphoto"
- *	Tcl command.
+ *	This function is invoked to process the "wm iconphoto" Tcl command.
  *	See the user documentation for details on what it does.
  *
  * Results:
@@ -2077,12 +2051,12 @@ WmIconnameCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmIconphotoCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmIconphotoCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     Tk_PhotoHandle photo;
@@ -2105,24 +2079,34 @@ WmIconphotoCmd(tkwin, winPtr, interp, objc, objv)
 	    return TCL_ERROR;
 	}
     }
+
     /*
      * Iterate over all images to retrieve their sizes, in order to allocate a
      * buffer large enough to hold all images.
      */
+
     for (i = 3 + isDefault; i < objc; i++) {
 	photo = Tk_FindPhoto(interp, Tcl_GetString(objv[i]));
 	if (photo == NULL) {
 	    Tcl_AppendResult(interp, "can't use \"", Tcl_GetString(objv[i]),
-		    "\" as iconphoto: not a photo image", (char *) NULL);
+		    "\" as iconphoto: not a photo image", NULL);
 	    return TCL_ERROR;
 	}
 	Tk_PhotoGetSize(photo, &width, &height);
-	/* We need to cardinals for width & height and one cardinal for each
-	 * image pixel. */
+
+	/*
+	 * We need to cardinals for width & height and one cardinal for each
+	 * image pixel.
+	 */
+
 	size += 2 + width * height;
     }
-    /* We have calculated the size of the data. Try to allocate the needed
-     * memory space. */
+
+    /*
+     * We have calculated the size of the data. Try to allocate the needed
+     * memory space.
+     */
+
     iconPropertyData = (long *) Tcl_AttemptAlloc(sizeof(long)*size);
     if (iconPropertyData == NULL) {
 	return TCL_ERROR;
@@ -2137,18 +2121,17 @@ WmIconphotoCmd(tkwin, winPtr, interp, objc, objv)
 	}
 	Tk_PhotoGetSize(photo, &width, &height);
 	Tk_PhotoGetImage(photo, &block);
+
 	/*
 	 * Each image data will be placed as an array of 32bit packed
-	 * CARDINAL, in a window property named "_NET_WM_ICON":
-	 * _NET_WM_ICON
+	 * CARDINAL, in a window property named "_NET_WM_ICON": _NET_WM_ICON
 	 *
 	 * _NET_WM_ICON CARDINAL[][2+n]/32
 	 *
-	 * This is an array of possible icons for the client.
-	 * This specification does not stipulate what size these icons should
-	 * be, but individual desktop environments or toolkits may do so.
-	 * The Window Manager MAY scale any of these icons to an appropriate
-	 * size.
+	 * This is an array of possible icons for the client. This spec. does
+	 * not stipulate what size these icons should be, but individual
+	 * desktop environments or toolkits may do so. The Window Manager MAY
+	 * scale any of these icons to an appropriate size.
 	 *
 	 * This is an array of 32bit packed CARDINAL ARGB with high byte being
 	 * A, low byte being B. The first two cardinals are width, height.
@@ -2158,6 +2141,7 @@ WmIconphotoCmd(tkwin, winPtr, interp, objc, objv)
 	/*
 	 * Encode the image data in the iconPropertyData array.
 	 */
+
 	iconPropertyData[index++] = width;
 	iconPropertyData[index++] = height;
 	for (y = 0; y < height; y++) {
@@ -2187,10 +2171,10 @@ WmIconphotoCmd(tkwin, winPtr, interp, objc, objv)
 	if (winPtr->dispPtr->iconDataPtr != NULL) {
 	    ckfree((char *) winPtr->dispPtr->iconDataPtr);
 	}
-	winPtr->dispPtr->iconDataPtr  = (unsigned char *) iconPropertyData;
+	winPtr->dispPtr->iconDataPtr = (unsigned char *) iconPropertyData;
 	winPtr->dispPtr->iconDataSize = size;
     } else {
-	wmPtr->iconDataPtr  = (unsigned char *) iconPropertyData;
+	wmPtr->iconDataPtr = (unsigned char *) iconPropertyData;
 	wmPtr->iconDataSize = size;
     }
     if (!(wmPtr->flags & WM_NEVER_MAPPED)) {
@@ -2204,8 +2188,7 @@ WmIconphotoCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmIconpositionCmd --
  *
- *	This procedure is invoked to process the "wm iconposition"
- *	Tcl command.
+ *	This function is invoked to process the "wm iconposition" Tcl command.
  *	See the user documentation for details on what it does.
  *
  * Results:
@@ -2218,12 +2201,12 @@ WmIconphotoCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmIconpositionCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmIconpositionCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     int x, y;
@@ -2262,7 +2245,7 @@ WmIconpositionCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmIconwindowCmd --
  *
- *	This procedure is invoked to process the "wm iconwindow" Tcl command.
+ *	This function is invoked to process the "wm iconwindow" Tcl command.
  *	See the user documentation for details on what it does.
  *
  * Results:
@@ -2275,12 +2258,12 @@ WmIconpositionCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmIconwindowCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmIconwindowCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     Tk_Window tkwin2;
@@ -2301,13 +2284,12 @@ WmIconwindowCmd(tkwin, winPtr, interp, objc, objv)
 	wmPtr->hints.flags &= ~IconWindowHint;
 	if (wmPtr->icon != NULL) {
 	    /*
-	     * Remove the icon window relationship.  In principle we
-	     * should also re-enable button events for the window, but
-	     * this doesn't work in general because the window manager
-	     * is probably selecting on them (we'll get an error if
-	     * we try to re-enable the events).  So, just leave the
-	     * icon window event-challenged;  the user will have to
-	     * recreate it if they want button events.
+	     * Remove the icon window relationship. In principle we should
+	     * also re-enable button events for the window, but this doesn't
+	     * work in general because the window manager is probably
+	     * selecting on them (we'll get an error if we try to re-enable
+	     * the events). So, just leave the icon window event-challenged;
+	     * the user will have to recreate it if they want button events.
 	     */
 
 	    wmPtr2 = ((TkWindow *) wmPtr->icon)->wmInfoPtr;
@@ -2322,14 +2304,14 @@ WmIconwindowCmd(tkwin, winPtr, interp, objc, objv)
 	}
 	if (!Tk_IsTopLevel(tkwin2)) {
 	    Tcl_AppendResult(interp, "can't use ", Tcl_GetString(objv[3]),
-		    " as icon window: not at top level", (char *) NULL);
+		    " as icon window: not at top level", NULL);
 	    return TCL_ERROR;
 	}
 	wmPtr2 = ((TkWindow *) tkwin2)->wmInfoPtr;
 	if (wmPtr2->iconFor != NULL) {
 	    Tcl_AppendResult(interp, Tcl_GetString(objv[3]),
-		    " is already an icon for ",
-		    Tk_PathName(wmPtr2->iconFor), (char *) NULL);
+		    " is already an icon for ", Tk_PathName(wmPtr2->iconFor),
+		    NULL);
 	    return TCL_ERROR;
 	}
 	if (wmPtr->icon != NULL) {
@@ -2340,10 +2322,9 @@ WmIconwindowCmd(tkwin, winPtr, interp, objc, objv)
 	}
 
 	/*
-	 * Disable button events in the icon window:  some window
-	 * managers (like olvwm) want to get the events themselves,
-	 * but X only allows one application at a time to receive
-	 * button events for a window.
+	 * Disable button events in the icon window: some window managers
+	 * (like olvwm) want to get the events themselves, but X only allows
+	 * one application at a time to receive button events for a window.
 	 */
 
 	atts.event_mask = Tk_Attributes(tkwin2)->event_mask
@@ -2379,8 +2360,8 @@ WmIconwindowCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmMaxsizeCmd --
  *
- *	This procedure is invoked to process the "wm maxsize" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm maxsize" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -2392,12 +2373,12 @@ WmIconwindowCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmMaxsizeCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmMaxsizeCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     int width, height;
@@ -2437,8 +2418,8 @@ WmMaxsizeCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmMinsizeCmd --
  *
- *	This procedure is invoked to process the "wm minsize" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm minsize" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -2450,12 +2431,12 @@ WmMaxsizeCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmMinsizeCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmMinsizeCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     int width, height;
@@ -2487,9 +2468,8 @@ WmMinsizeCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmOverrideredirectCmd --
  *
- *	This procedure is invoked to process the "wm overrideredirect"
- *	Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm overrideredirect" Tcl
+ *	command. See the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -2501,12 +2481,12 @@ WmMinsizeCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmOverrideredirectCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmOverrideredirectCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     int boolean, curValue;
     XSetWindowAttributes atts;
@@ -2525,9 +2505,10 @@ WmOverrideredirectCmd(tkwin, winPtr, interp, objc, objv)
     }
     if (curValue != boolean) {
 	/*
-	 * Only do this if we are really changing value, because it
-	 * causes some funky stuff to occur
+	 * Only do this if we are really changing value, because it causes
+	 * some funky stuff to occur
 	 */
+
 	atts.override_redirect = (boolean) ? True : False;
 	Tk_ChangeWindowAttributes((Tk_Window) winPtr, CWOverrideRedirect,
 		&atts);
@@ -2545,8 +2526,7 @@ WmOverrideredirectCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmPositionfromCmd --
  *
- *	This procedure is invoked to process the "wm positionfrom"
- *	Tcl command.
+ *	This function is invoked to process the "wm positionfrom" Tcl command.
  *	See the user documentation for details on what it does.
  *
  * Results:
@@ -2559,16 +2539,16 @@ WmOverrideredirectCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmPositionfromCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmPositionfromCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     static CONST char *optionStrings[] = {
-	"program", "user", (char *) NULL };
+	"program", "user", NULL };
     enum options {
 	OPT_PROGRAM, OPT_USER };
     int index;
@@ -2610,8 +2590,8 @@ WmPositionfromCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmProtocolCmd --
  *
- *	This procedure is invoked to process the "wm protocol" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm protocol" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -2623,12 +2603,12 @@ WmPositionfromCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmProtocolCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmProtocolCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     register ProtocolHandler *protPtr, *prevPtr;
@@ -2644,8 +2624,9 @@ WmProtocolCmd(tkwin, winPtr, interp, objc, objv)
 	/*
 	 * Return a list of all defined protocols for the window.
 	 */
+
 	for (protPtr = wmPtr->protPtr; protPtr != NULL;
-	     protPtr = protPtr->nextPtr) {
+		protPtr = protPtr->nextPtr) {
 	    Tcl_AppendElement(interp,
 		    Tk_GetAtomName((Tk_Window) winPtr, protPtr->protocol));
 	}
@@ -2656,8 +2637,9 @@ WmProtocolCmd(tkwin, winPtr, interp, objc, objv)
 	/*
 	 * Return the command to handle a given protocol.
 	 */
+
 	for (protPtr = wmPtr->protPtr; protPtr != NULL;
-	     protPtr = protPtr->nextPtr) {
+		protPtr = protPtr->nextPtr) {
 	    if (protPtr->protocol == protocol) {
 		Tcl_SetResult(interp, protPtr->command, TCL_STATIC);
 		return TCL_OK;
@@ -2667,13 +2649,12 @@ WmProtocolCmd(tkwin, winPtr, interp, objc, objv)
     }
 
     /*
-     * Delete any current protocol handler, then create a new
-     * one with the specified command, unless the command is
-     * empty.
+     * Delete any current protocol handler, then create a new one with the
+     * specified command, unless the command is empty.
      */
 
     for (protPtr = wmPtr->protPtr, prevPtr = NULL; protPtr != NULL;
-	 prevPtr = protPtr, protPtr = protPtr->nextPtr) {
+	    prevPtr = protPtr, protPtr = protPtr->nextPtr) {
 	if (protPtr->protocol == protocol) {
 	    if (prevPtr == NULL) {
 		wmPtr->protPtr = protPtr->nextPtr;
@@ -2704,7 +2685,7 @@ WmProtocolCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmResizableCmd --
  *
- *	This procedure is invoked to process the "wm resizable" Tcl command.
+ *	This function is invoked to process the "wm resizable" Tcl command.
  *	See the user documentation for details on what it does.
  *
  * Results:
@@ -2717,12 +2698,12 @@ WmProtocolCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmResizableCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmResizableCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     int width, height;
@@ -2735,8 +2716,8 @@ WmResizableCmd(tkwin, winPtr, interp, objc, objv)
 	char buf[TCL_INTEGER_SPACE * 2];
 
 	sprintf(buf, "%d %d",
-		(wmPtr->flags  & WM_WIDTH_NOT_RESIZABLE) ? 0 : 1,
-		(wmPtr->flags  & WM_HEIGHT_NOT_RESIZABLE) ? 0 : 1);
+		(wmPtr->flags & WM_WIDTH_NOT_RESIZABLE) ? 0 : 1,
+		(wmPtr->flags & WM_HEIGHT_NOT_RESIZABLE) ? 0 : 1);
 	Tcl_SetResult(interp, buf, TCL_VOLATILE);
 	return TCL_OK;
     }
@@ -2764,8 +2745,8 @@ WmResizableCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmSizefromCmd --
  *
- *	This procedure is invoked to process the "wm sizefrom" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm sizefrom" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -2777,16 +2758,16 @@ WmResizableCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmSizefromCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmSizefromCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     static CONST char *optionStrings[] = {
-	"program", "user", (char *) NULL };
+	"program", "user", NULL };
     enum options {
 	OPT_PROGRAM, OPT_USER };
     int index;
@@ -2829,7 +2810,7 @@ WmSizefromCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmStackorderCmd --
  *
- *	This procedure is invoked to process the "wm stackorder" Tcl command.
+ *	This function is invoked to process the "wm stackorder" Tcl command.
  *	See the user documentation for details on what it does.
  *
  * Results:
@@ -2842,16 +2823,16 @@ WmSizefromCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmStackorderCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmStackorderCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     TkWindow **windows, **window_ptr;
     static CONST char *optionStrings[] = {
-	"isabove", "isbelow", (char *) NULL };
+	"isabove", "isbelow", NULL };
     enum options {
 	OPT_ISABOVE, OPT_ISBELOW };
     int index;
@@ -2883,45 +2864,47 @@ WmStackorderCmd(tkwin, winPtr, interp, objc, objv)
 
 	if (!Tk_IsTopLevel(winPtr2)) {
 	    Tcl_AppendResult(interp, "window \"", winPtr2->pathName,
-		    "\" isn't a top-level window", (char *) NULL);
+		    "\" isn't a top-level window", NULL);
 	    return TCL_ERROR;
 	}
 
 	if (!Tk_IsMapped(winPtr)) {
 	    Tcl_AppendResult(interp, "window \"", winPtr->pathName,
-		    "\" isn't mapped", (char *) NULL);
+		    "\" isn't mapped", NULL);
 	    return TCL_ERROR;
 	}
 
 	if (!Tk_IsMapped(winPtr2)) {
 	    Tcl_AppendResult(interp, "window \"", winPtr2->pathName,
-		    "\" isn't mapped", (char *) NULL);
+		    "\" isn't mapped", NULL);
 	    return TCL_ERROR;
 	}
 
 	/*
-	 * Lookup stacking order of all toplevels that are children
-	 * of "." and find the position of winPtr and winPtr2
-	 * in the stacking order.
+	 * Lookup stacking order of all toplevels that are children of "." and
+	 * find the position of winPtr and winPtr2 in the stacking order.
 	 */
 
 	windows = TkWmStackorderToplevel(winPtr->mainPtr->winPtr);
 
 	if (windows == NULL) {
-	    Tcl_AppendResult(interp, "TkWmStackorderToplevel failed",
-                    (char *) NULL);
+	    Tcl_AppendResult(interp, "TkWmStackorderToplevel failed", NULL);
 	    return TCL_ERROR;
 	} else {
 	    for (window_ptr = windows; *window_ptr ; window_ptr++) {
-		if (*window_ptr == winPtr)
+		if (*window_ptr == winPtr) {
 		    index1 = (window_ptr - windows);
-		if (*window_ptr == winPtr2)
+		}
+		if (*window_ptr == winPtr2) {
 		    index2 = (window_ptr - windows);
+		}
 	    }
-	    if (index1 == -1)
+	    if (index1 == -1) {
 		Tcl_Panic("winPtr window not found");
-	    if (index2 == -1)
+	    }
+	    if (index2 == -1) {
 		Tcl_Panic("winPtr2 window not found");
+	    }
 
 	    ckfree((char *) windows);
 	}
@@ -2946,8 +2929,8 @@ WmStackorderCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmStateCmd --
  *
- *	This procedure is invoked to process the "wm state" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm state" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -2959,16 +2942,16 @@ WmStackorderCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmStateCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmStateCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     static CONST char *optionStrings[] = {
-	"normal", "iconic", "withdrawn", (char *) NULL };
+	"normal", "iconic", "withdrawn", NULL };
     enum options {
 	OPT_NORMAL, OPT_ICONIC, OPT_WITHDRAWN };
     int index;
@@ -2980,9 +2963,8 @@ WmStateCmd(tkwin, winPtr, interp, objc, objv)
     if (objc == 4) {
 	if (wmPtr->iconFor != NULL) {
 	    Tcl_AppendResult(interp, "can't change state of ",
-		    Tcl_GetString(objv[2]),
-		    ": it is an icon for ", Tk_PathName(wmPtr->iconFor),
-		    (char *) NULL);
+		    Tcl_GetString(objv[2]), ": it is an icon for ",
+		    Tk_PathName(wmPtr->iconFor), NULL);
 	    return TCL_ERROR;
 	}
 
@@ -2996,16 +2978,13 @@ WmStateCmd(tkwin, winPtr, interp, objc, objv)
 	    (void) TkpWmSetState(winPtr, NormalState);
 	} else if (index == OPT_ICONIC) {
 	    if (Tk_Attributes((Tk_Window) winPtr)->override_redirect) {
-		Tcl_AppendResult(interp, "can't iconify \"",
-			winPtr->pathName,
-			"\": override-redirect flag is set",
-			(char *) NULL);
+		Tcl_AppendResult(interp, "can't iconify \"", winPtr->pathName,
+			"\": override-redirect flag is set", NULL);
 		return TCL_ERROR;
 	    }
 	    if (wmPtr->masterPtr != NULL) {
-		Tcl_AppendResult(interp, "can't iconify \"",
-			winPtr->pathName,
-			"\": it is a transient", (char *) NULL);
+		Tcl_AppendResult(interp, "can't iconify \"", winPtr->pathName,
+			"\": it is a transient", NULL);
 		return TCL_ERROR;
 	    }
 	    if (TkpWmSetState(winPtr, IconicState) == 0) {
@@ -3044,8 +3023,8 @@ WmStateCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmTitleCmd --
  *
- *	This procedure is invoked to process the "wm title" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm title" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -3057,12 +3036,12 @@ WmStateCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmTitleCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmTitleCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     char *argv3;
@@ -3097,7 +3076,7 @@ WmTitleCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmTransientCmd --
  *
- *	This procedure is invoked to process the "wm transient" Tcl command.
+ *	This function is invoked to process the "wm transient" Tcl command.
  *	See the user documentation for details on what it does.
  *
  * Results:
@@ -3110,12 +3089,12 @@ WmTitleCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmTransientCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmTransientCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     TkWindow *masterPtr = wmPtr->masterPtr;
@@ -3134,18 +3113,19 @@ WmTransientCmd(tkwin, winPtr, interp, objc, objv)
     if (Tcl_GetString(objv[3])[0] == '\0') {
 	if (masterPtr != NULL) {
 	    /*
-	     * If we had a master, tell them that we aren't tied
-	     * to them anymore
+	     * If we had a master, tell them that we aren't tied to them
+	     * anymore
 	     */
 
 	    masterPtr->wmInfoPtr->numTransients--;
-	    Tk_DeleteEventHandler((Tk_Window) masterPtr,
-		    StructureNotifyMask,
+	    Tk_DeleteEventHandler((Tk_Window) masterPtr, StructureNotifyMask,
 		    WmWaitMapProc, (ClientData) winPtr);
 
-	    /* FIXME: Need a call like Win32's UpdateWrapper() so
-	       we can recreate the wrapper and get rid of the
-	       transient window decorations. */
+	    /*
+	     * FIXME: Need a call like Win32's UpdateWrapper() so we can
+	     * recreate the wrapper and get rid of the transient window
+	     * decorations.
+	     */
 	}
 
 	wmPtr->masterPtr = NULL;
@@ -3164,11 +3144,9 @@ WmTransientCmd(tkwin, winPtr, interp, objc, objv)
 	Tk_MakeWindowExist((Tk_Window) masterPtr);
 
 	if (wmPtr->iconFor != NULL) {
-	    Tcl_AppendResult(interp, "can't make \"",
-		    Tcl_GetString(objv[2]),
+	    Tcl_AppendResult(interp, "can't make \"", Tcl_GetString(objv[2]),
 		    "\" a transient: it is an icon for ",
-		    Tk_PathName(wmPtr->iconFor),
-		    (char *) NULL);
+		    Tk_PathName(wmPtr->iconFor), NULL);
 	    return TCL_ERROR;
 	}
 
@@ -3178,24 +3156,21 @@ WmTransientCmd(tkwin, winPtr, interp, objc, objv)
 	}
 
 	if (wmPtr2->iconFor != NULL) {
-	    Tcl_AppendResult(interp, "can't make \"",
-		    Tcl_GetString(objv[3]),
+	    Tcl_AppendResult(interp, "can't make \"", Tcl_GetString(objv[3]),
 		    "\" a master: it is an icon for ",
-		    Tk_PathName(wmPtr2->iconFor),
-		    (char *) NULL);
+		    Tk_PathName(wmPtr2->iconFor), NULL);
 	    return TCL_ERROR;
 	}
 
 	if (masterPtr == winPtr) {
 	    Tcl_AppendResult(interp, "can't make \"", Tk_PathName(winPtr),
-		    "\" its own master",
-		    (char *) NULL);
+		    "\" its own master", NULL);
 	    return TCL_ERROR;
 	} else if (masterPtr != wmPtr->masterPtr) {
 	    /*
-	     * Remove old master map/unmap binding before setting
-	     * the new master. The event handler will ensure that
-	     * transient states reflect the state of the master.
+	     * Remove old master map/unmap binding before setting the new
+	     * master. The event handler will ensure that transient states
+	     * reflect the state of the master.
 	     */
 
 	    if (wmPtr->masterPtr != NULL) {
@@ -3207,8 +3182,7 @@ WmTransientCmd(tkwin, winPtr, interp, objc, objv)
 
 	    masterPtr->wmInfoPtr->numTransients++;
 	    Tk_CreateEventHandler((Tk_Window) masterPtr,
-		    StructureNotifyMask,
-		    WmWaitMapProc, (ClientData) winPtr);
+		    StructureNotifyMask, WmWaitMapProc, (ClientData) winPtr);
 
 	    wmPtr->masterPtr = masterPtr;
 	}
@@ -3223,7 +3197,8 @@ WmTransientCmd(tkwin, winPtr, interp, objc, objv)
 	    }
 	} else {
 	    if (wmPtr->masterPtr != NULL) {
-		XSetTransientForHint(winPtr->display, wmPtr->wrapperPtr->window,
+		XSetTransientForHint(winPtr->display,
+			wmPtr->wrapperPtr->window,
 			wmPtr->masterPtr->wmInfoPtr->wrapperPtr->window);
 	    } else {
 		XDeleteProperty(winPtr->display, wmPtr->wrapperPtr->window,
@@ -3239,8 +3214,8 @@ WmTransientCmd(tkwin, winPtr, interp, objc, objv)
  *
  * WmWithdrawCmd --
  *
- *	This procedure is invoked to process the "wm withdraw" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "wm withdraw" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -3252,12 +3227,12 @@ WmTransientCmd(tkwin, winPtr, interp, objc, objv)
  */
 
 static int
-WmWithdrawCmd(tkwin, winPtr, interp, objc, objv)
-    Tk_Window tkwin;		/* Main window of the application. */
-    TkWindow *winPtr;           /* Toplevel to work with */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument objects. */
+WmWithdrawCmd(
+    Tk_Window tkwin,		/* Main window of the application. */
+    TkWindow *winPtr,		/* Toplevel to work with */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
 
@@ -3267,8 +3242,7 @@ WmWithdrawCmd(tkwin, winPtr, interp, objc, objv)
     }
     if (wmPtr->iconFor != NULL) {
 	Tcl_AppendResult(interp, "can't withdraw ", Tcl_GetString(objv[2]),
-		": it is an icon for ", Tk_PathName(wmPtr->iconFor),
-		(char *) NULL);
+		": it is an icon for ", Tk_PathName(wmPtr->iconFor), NULL);
 	return TCL_ERROR;
     }
     wmPtr->flags |= WM_WITHDRAWN;
@@ -3282,13 +3256,14 @@ WmWithdrawCmd(tkwin, winPtr, interp, objc, objv)
 }
 
 /*
- * Invoked by those wm subcommands that affect geometry.
- * Schedules a geometry update.
+ * Invoked by those wm subcommands that affect geometry. Schedules a geometry
+ * update.
  */
+
 static void
-WmUpdateGeom(wmPtr, winPtr)
-    WmInfo *wmPtr;
-    TkWindow *winPtr;
+WmUpdateGeom(
+    WmInfo *wmPtr,
+    TkWindow *winPtr)
 {
     if (!(wmPtr->flags & (WM_UPDATE_PENDING|WM_NEVER_MAPPED))) {
 	Tcl_DoWhenIdle(UpdateGeometryInfo, (ClientData) winPtr);
@@ -3297,25 +3272,28 @@ WmUpdateGeom(wmPtr, winPtr)
 }
 
 /*
- * Invoked when a MapNotify or UnmapNotify event is delivered for a
- * toplevel that is the master of a transient toplevel.
+ * Invoked when a MapNotify or UnmapNotify event is delivered for a toplevel
+ * that is the master of a transient toplevel.
  */
+
 static void
-WmWaitMapProc(clientData, eventPtr)
-    ClientData clientData;	/* Pointer to window. */
-    XEvent *eventPtr;		/* Information about event. */
+WmWaitMapProc(
+    ClientData clientData,	/* Pointer to window. */
+    XEvent *eventPtr)		/* Information about event. */
 {
     TkWindow *winPtr = (TkWindow *) clientData;
     TkWindow *masterPtr = winPtr->wmInfoPtr->masterPtr;
 
-    if (masterPtr == NULL)
-        return;
+    if (masterPtr == NULL) {
+	return;
+    }
 
     if (eventPtr->type == MapNotify) {
-        if (!(winPtr->wmInfoPtr->flags & WM_WITHDRAWN))
-            (void) TkpWmSetState(winPtr, NormalState);
+	if (!(winPtr->wmInfoPtr->flags & WM_WITHDRAWN)) {
+	    (void) TkpWmSetState(winPtr, NormalState);
+	}
     } else if (eventPtr->type == UnmapNotify) {
-        (void) TkpWmSetState(winPtr, WithdrawnState);
+	(void) TkpWmSetState(winPtr, WithdrawnState);
     }
 }
 
@@ -3324,34 +3302,34 @@ WmWaitMapProc(clientData, eventPtr)
  *
  * Tk_SetGrid --
  *
- *	This procedure is invoked by a widget when it wishes to set a grid
- *	coordinate system that controls the size of a top-level window.
- *	It provides a C interface equivalent to the "wm grid" command and
- *	is usually asscoiated with the -setgrid option.
+ *	This function is invoked by a widget when it wishes to set a grid
+ *	coordinate system that controls the size of a top-level window. It
+ *	provides a C interface equivalent to the "wm grid" command and is
+ *	usually asscoiated with the -setgrid option.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Grid-related information will be passed to the window manager, so
- *	that the top-level window associated with tkwin will resize on
- *	even grid units.  If some other window already controls gridding
- *	for the top-level window then this procedure call has no effect.
+ *	Grid-related information will be passed to the window manager, so that
+ *	the top-level window associated with tkwin will resize on even grid
+ *	units. If some other window already controls gridding for the
+ *	top-level window then this function call has no effect.
  *
  *----------------------------------------------------------------------
  */
 
 void
-Tk_SetGrid(tkwin, reqWidth, reqHeight, widthInc, heightInc)
-    Tk_Window tkwin;		/* Token for window.  New window mgr info
-				 * will be posted for the top-level window
+Tk_SetGrid(
+    Tk_Window tkwin,		/* Token for window. New window mgr info will
+				 * be posted for the top-level window
 				 * associated with this window. */
-    int reqWidth;		/* Width (in grid units) corresponding to
-				 * the requested geometry for tkwin. */
-    int reqHeight;		/* Height (in grid units) corresponding to
-				 * the requested geometry for tkwin. */
-    int widthInc, heightInc;	/* Pixel increments corresponding to a
-				 * change of one grid unit. */
+    int reqWidth,		/* Width (in grid units) corresponding to the
+				 * requested geometry for tkwin. */
+    int reqHeight,		/* Height (in grid units) corresponding to the
+				 * requested geometry for tkwin. */
+    int widthInc, int heightInc)/* Pixel increments corresponding to a change
+				 * of one grid unit. */
 {
     TkWindow *winPtr = (TkWindow *) tkwin;
     register WmInfo *wmPtr;
@@ -3359,6 +3337,7 @@ Tk_SetGrid(tkwin, reqWidth, reqHeight, widthInc, heightInc)
     /*
      * Ensure widthInc and heightInc are greater than 0
      */
+
     if (widthInc <= 0) {
 	widthInc = 1;
     }
@@ -3400,15 +3379,15 @@ Tk_SetGrid(tkwin, reqWidth, reqHeight, widthInc, heightInc)
     }
 
     /*
-     * If gridding was previously off, then forget about any window
-     * size requests made by the user or via "wm geometry":  these are
-     * in pixel units and there's no easy way to translate them to
-     * grid units since the new requested size of the top-level window in
-     * pixels may not yet have been registered yet (it may filter up
-     * the hierarchy in DoWhenIdle handlers).  However, if the window
-     * has never been mapped yet then just leave the window size alone:
-     * assume that it is intended to be in grid units but just happened
-     * to have been specified before this procedure was called.
+     * If gridding was previously off, then forget about any window size
+     * requests made by the user or via "wm geometry": these are in pixel
+     * units and there's no easy way to translate them to grid units since the
+     * new requested size of the top-level window in pixels may not yet have
+     * been registered yet (it may filter up the hierarchy in DoWhenIdle
+     * handlers). However, if the window has never been mapped yet then just
+     * leave the window size alone: assume that it is intended to be in grid
+     * units but just happened to have been specified before this function was
+     * called.
      */
 
     if ((wmPtr->gridWin == NULL) && !(wmPtr->flags & WM_NEVER_MAPPED)) {
@@ -3417,8 +3396,8 @@ Tk_SetGrid(tkwin, reqWidth, reqHeight, widthInc, heightInc)
     }
 
     /*
-     * Set the new gridding information, and start the process of passing
-     * all of this information to the window manager.
+     * Set the new gridding information, and start the process of passing all
+     * of this information to the window manager.
      */
 
     wmPtr->gridWin = tkwin;
@@ -3439,23 +3418,22 @@ Tk_SetGrid(tkwin, reqWidth, reqHeight, widthInc, heightInc)
  *
  * Tk_UnsetGrid --
  *
- *	This procedure cancels the effect of a previous call
- *	to Tk_SetGrid.
+ *	This function cancels the effect of a previous call to Tk_SetGrid.
  *
  * Results:
  *	None.
  *
  * Side effects:
  *	If tkwin currently controls gridding for its top-level window,
- *	gridding is cancelled for that top-level window;  if some other
- *	window controls gridding then this procedure has no effect.
+ *	gridding is cancelled for that top-level window; if some other window
+ *	controls gridding then this function has no effect.
  *
  *----------------------------------------------------------------------
  */
 
 void
-Tk_UnsetGrid(tkwin)
-    Tk_Window tkwin;		/* Token for window that is currently
+Tk_UnsetGrid(
+    Tk_Window tkwin)		/* Token for window that is currently
 				 * controlling gridding. */
 {
     TkWindow *winPtr = (TkWindow *) tkwin;
@@ -3508,24 +3486,25 @@ Tk_UnsetGrid(tkwin)
  *
  * ConfigureEvent --
  *
- *	This procedure is called to handle ConfigureNotify events on
- *	wrapper windows.
+ *	This function is called to handle ConfigureNotify events on wrapper
+ *	windows.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Information gets updated in the WmInfo structure for the window
- *	and the toplevel itself gets repositioned within the wrapper.
+ *	Information gets updated in the WmInfo structure for the window and
+ *	the toplevel itself gets repositioned within the wrapper.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-ConfigureEvent(wmPtr, configEventPtr)
-    WmInfo *wmPtr;			/* Information about toplevel window. */
-    XConfigureEvent *configEventPtr;	/* Event that just occurred for
-					 * wmPtr->wrapperPtr. */
+ConfigureEvent(
+    WmInfo *wmPtr,		/* Information about toplevel window. */
+    XConfigureEvent *configEventPtr)
+				/* Event that just occurred for
+				 * wmPtr->wrapperPtr. */
 {
     TkWindow *wrapperPtr = wmPtr->wrapperPtr;
     TkWindow *winPtr = wmPtr->winPtr;
@@ -3533,21 +3512,21 @@ ConfigureEvent(wmPtr, configEventPtr)
     Tk_ErrorHandler handler;
 
     /*
-     * Update size information from the event.  There are a couple of
-     * tricky points here:
+     * Update size information from the event. There are a couple of tricky
+     * points here:
      *
-     * 1. If the user changed the size externally then set wmPtr->width
-     *    and wmPtr->height just as if a "wm geometry" command had been
-     *    invoked with the same information.
-     * 2. However, if the size is changing in response to a request
-     *    coming from us (WM_SYNC_PENDING is set), then don't set wmPtr->width
-     *    or wmPtr->height if they were previously -1 (otherwise the
-     *    window will stop tracking geometry manager requests).
+     * 1. If the user changed the size externally then set wmPtr->width and
+     *    wmPtr->height just as if a "wm geometry" command had been invoked
+     *    with the same information.
+     * 2. However, if the size is changing in response to a request coming
+     *    from us (WM_SYNC_PENDING is set), then don't set wmPtr->width or
+     *    wmPtr->height if they were previously -1 (otherwise the window will
+     *    stop tracking geometry manager requests).
      */
 
     if (((wrapperPtr->changes.width != configEventPtr->width)
 	    || (wrapperPtr->changes.height != configEventPtr->height))
-	    && !(wmPtr->flags & WM_SYNC_PENDING)){
+	    && !(wmPtr->flags & WM_SYNC_PENDING)) {
 	if (dispPtr->flags & TK_DISPLAY_WM_TRACING) {
 	    printf("TopLevelEventProc: user changed %s size to %dx%d\n",
 		    winPtr->pathName, configEventPtr->width,
@@ -3556,17 +3535,17 @@ ConfigureEvent(wmPtr, configEventPtr)
 	if ((wmPtr->width == -1)
 		&& (configEventPtr->width == winPtr->reqWidth)) {
 	    /*
-	     * Don't set external width, since the user didn't change it
-	     * from what the widgets asked for.
+	     * Don't set external width, since the user didn't change it from
+	     * what the widgets asked for.
 	     */
 	} else {
 	    /*
 	     * Note: if this window is embedded then don't set the external
 	     * size, since it came from the containing application, not the
-	     * user.  In this case we want to keep sending our size requests
-	     * to the containing application;  if the user fixes the size
-	     * of that application then it will still percolate down to us
-	     * in the right way.
+	     * user. In this case we want to keep sending our size requests to
+	     * the containing application; if the user fixes the size of that
+	     * application then it will still percolate down to us in the
+	     * right way.
 	     */
 
 	    if (!(winPtr->flags & TK_EMBEDDED)) {
@@ -3586,13 +3565,13 @@ ConfigureEvent(wmPtr, configEventPtr)
 		&& (configEventPtr->height ==
 			(winPtr->reqHeight + wmPtr->menuHeight))) {
 	    /*
-	     * Don't set external height, since the user didn't change it
-	     * from what the widgets asked for.
+	     * Don't set external height, since the user didn't change it from
+	     * what the widgets asked for.
 	     */
 	} else {
 	    /*
-	     * See note for wmPtr->width about not setting external size
-	     * for embedded windows.
+	     * See note for wmPtr->width about not setting external size for
+	     * embedded windows.
 	     */
 
 	    if (!(winPtr->flags & TK_EMBEDDED)) {
@@ -3606,7 +3585,7 @@ ConfigureEvent(wmPtr, configEventPtr)
 		} else {
 		    wmPtr->height = configEventPtr->height - wmPtr->menuHeight;
 		}
-            }
+	    }
 	}
 	wmPtr->configWidth = configEventPtr->width;
 	wmPtr->configHeight = configEventPtr->height;
@@ -3627,19 +3606,17 @@ ConfigureEvent(wmPtr, configEventPtr)
     wrapperPtr->changes.stack_mode = Above;
 
     /*
-     * Reparenting window managers make life difficult.  If the
-     * window manager reparents a top-level window then the x and y
-     * information that comes in events for the window is wrong:
-     * it gives the location of the window inside its decorative
-     * parent, rather than the location of the window in root
-     * coordinates, which is what we want.  Window managers
-     * are supposed to send synthetic events with the correct
-     * information, but ICCCM doesn't require them to do this
-     * under all conditions, and the information provided doesn't
-     * include everything we need here.  So, the code below
-     * maintains a bunch of information about the parent window.
-     * If the window hasn't been reparented, we pretend that
-     * there is a parent shrink-wrapped around the window.
+     * Reparenting window managers make life difficult. If the window manager
+     * reparents a top-level window then the x and y information that comes in
+     * events for the window is wrong: it gives the location of the window
+     * inside its decorative parent, rather than the location of the window in
+     * root coordinates, which is what we want. Window managers are supposed
+     * to send synthetic events with the correct information, but ICCCM
+     * doesn't require them to do this under all conditions, and the
+     * information provided doesn't include everything we need here. So, the
+     * code below maintains a bunch of information about the parent window.
+     * If the window hasn't been reparented, we pretend that there is a parent
+     * shrink-wrapped around the window.
      */
 
     if (dispPtr->flags & TK_DISPLAY_WM_TRACING) {
@@ -3665,11 +3642,11 @@ ConfigureEvent(wmPtr, configEventPtr)
 
     /*
      * Make sure that the toplevel and menubar are properly positioned within
-     * the wrapper.  If the menuHeight happens to be zero, we'll get a
-     * BadValue X error that we want to ignore [Bug: 3377]
+     * the wrapper. If the menuHeight happens to be zero, we'll get a BadValue
+     * X error that we want to ignore [Bug: 3377]
      */
-    handler = Tk_CreateErrorHandler(winPtr->display, -1, -1, -1,
-	    (Tk_ErrorProc *) NULL, (ClientData) NULL);
+
+    handler = Tk_CreateErrorHandler(winPtr->display, -1, -1, -1, NULL, NULL);
     XMoveResizeWindow(winPtr->display, winPtr->window, 0,
 	    wmPtr->menuHeight, (unsigned) wrapperPtr->changes.width,
 	    (unsigned) (wrapperPtr->changes.height - wmPtr->menuHeight));
@@ -3683,9 +3660,9 @@ ConfigureEvent(wmPtr, configEventPtr)
 
     /*
      * Update the coordinates in the toplevel (they should refer to the
-     * position in root window coordinates, not the coordinates of the
-     * wrapper window).  Then synthesize a ConfigureNotify event to tell
-     * the application about the change.
+     * position in root window coordinates, not the coordinates of the wrapper
+     * window). Then synthesize a ConfigureNotify event to tell the
+     * application about the change.
      */
 
     winPtr->changes.x = wrapperPtr->changes.x;
@@ -3700,8 +3677,8 @@ ConfigureEvent(wmPtr, configEventPtr)
  *
  * ReparentEvent --
  *
- *	This procedure is called to handle ReparentNotify events on
- *	wrapper windows.
+ *	This function is called to handle ReparentNotify events on wrapper
+ *	windows.
  *
  * Results:
  *	None.
@@ -3713,10 +3690,11 @@ ConfigureEvent(wmPtr, configEventPtr)
  */
 
 static void
-ReparentEvent(wmPtr, reparentEventPtr)
-    WmInfo *wmPtr;			/* Information about toplevel window. */
-    XReparentEvent *reparentEventPtr;	/* Event that just occurred for
-					 * wmPtr->wrapperPtr. */
+ReparentEvent(
+    WmInfo *wmPtr,		/* Information about toplevel window. */
+    XReparentEvent *reparentEventPtr)
+				/* Event that just occurred for
+				 * wmPtr->wrapperPtr. */
 {
     TkWindow *wrapperPtr = wmPtr->wrapperPtr;
     Window vRoot, ancestor, *children, dummy2, *virtualRootPtr;
@@ -3728,17 +3706,16 @@ ReparentEvent(wmPtr, reparentEventPtr)
     TkDisplay *dispPtr = wmPtr->winPtr->dispPtr;
 
     /*
-     * Identify the root window for wrapperPtr.  This is tricky because of
-     * virtual root window managers like tvtwm.  If the window has a
-     * property named __SWM_ROOT or __WM_ROOT then this property gives
-     * the id for a virtual root window that should be used instead of
-     * the root window of the screen.
+     * Identify the root window for wrapperPtr. This is tricky because of
+     * virtual root window managers like tvtwm. If the window has a property
+     * named __SWM_ROOT or __WM_ROOT then this property gives the id for a
+     * virtual root window that should be used instead of the root window of
+     * the screen.
      */
 
     vRoot = RootWindow(wrapperPtr->display, wrapperPtr->screenNum);
     wmPtr->vRoot = None;
-    handler = Tk_CreateErrorHandler(wrapperPtr->display, -1, -1, -1,
-	    (Tk_ErrorProc *) NULL, (ClientData) NULL);
+    handler = Tk_CreateErrorHandler(wrapperPtr->display, -1,-1,-1, NULL,NULL);
     if (((XGetWindowProperty(wrapperPtr->display, wrapperPtr->window,
 	    Tk_InternAtom((Tk_Window) wrapperPtr, "__WM_ROOT"), 0, (long) 1,
 	    False, XA_WINDOW, &actualType, &actualFormat, &numItems,
@@ -3773,12 +3750,12 @@ ReparentEvent(wmPtr, reparentEventPtr)
     UpdateVRootGeometry(wmPtr);
 
     /*
-     * If the window's new parent is the root window, then mark it as
-     * no longer reparented.
+     * If the window's new parent is the root window, then mark it as no
+     * longer reparented.
      */
 
     if (reparentEventPtr->parent == vRoot) {
-	noReparent:
+    noReparent:
 	wmPtr->reparent = None;
 	wmPtr->parentWidth = wrapperPtr->changes.width;
 	wmPtr->parentHeight = wrapperPtr->changes.height;
@@ -3791,17 +3768,15 @@ ReparentEvent(wmPtr, reparentEventPtr)
     }
 
     /*
-     * Search up the window hierarchy to find the ancestor of this
-     * window that is just below the (virtual) root.  This is tricky
-     * because it's possible that things have changed since the event
-     * was generated so that the ancestry indicated by the event no
-     * longer exists.  If this happens then an error will occur and
-     * we just discard the event (there will be a more up-to-date
-     * ReparentNotify event coming later).
+     * Search up the window hierarchy to find the ancestor of this window that
+     * is just below the (virtual) root. This is tricky because it's possible
+     * that things have changed since the event was generated so that the
+     * ancestry indicated by the event no longer exists. If this happens then
+     * an error will occur and we just discard the event (there will be a more
+     * up-to-date ReparentNotify event coming later).
      */
 
-    handler = Tk_CreateErrorHandler(wrapperPtr->display, -1, -1, -1,
-	    (Tk_ErrorProc *) NULL, (ClientData) NULL);
+    handler = Tk_CreateErrorHandler(wrapperPtr->display, -1,-1,-1, NULL,NULL);
     wmPtr->reparent = reparentEventPtr->parent;
     while (1) {
 	if (XQueryTree(wrapperPtr->display, wmPtr->reparent, &dummy2,
@@ -3829,28 +3804,26 @@ ReparentEvent(wmPtr, reparentEventPtr)
  *
  * ComputeReparentGeometry --
  *
- *	This procedure is invoked to recompute geometry information
- *	related to a reparented top-level window, such as the position
- *	and total size of the parent and the position within it of
- *	the top-level window.
+ *	This function is invoked to recompute geometry information related to
+ *	a reparented top-level window, such as the position and total size of
+ *	the parent and the position within it of the top-level window.
  *
  * Results:
- *	The return value is 1 if everything completed successfully
- *	and 0 if an error occurred while querying information about
- *	winPtr's parents.  In this case winPtr is marked as no longer
- *	being reparented.
+ *	The return value is 1 if everything completed successfully and 0 if an
+ *	error occurred while querying information about winPtr's parents. In
+ *	this case winPtr is marked as no longer being reparented.
  *
  * Side effects:
- *	Geometry information in wmPtr, wmPtr->winPtr, and
- *	wmPtr->wrapperPtr gets updated.
+ *	Geometry information in wmPtr, wmPtr->winPtr, and wmPtr->wrapperPtr
+ *	gets updated.
  *
  *----------------------------------------------------------------------
  */
 
 static int
-ComputeReparentGeometry(wmPtr)
-    WmInfo *wmPtr;		/* Information about toplevel window
-				 * whose reparent info is to be recomputed. */
+ComputeReparentGeometry(
+    WmInfo *wmPtr)		/* Information about toplevel window whose
+				 * reparent info is to be recomputed. */
 {
     TkWindow *wrapperPtr = wmPtr->wrapperPtr;
     int width, height, bd;
@@ -3861,8 +3834,7 @@ ComputeReparentGeometry(wmPtr)
     Tk_ErrorHandler handler;
     TkDisplay *dispPtr = wmPtr->winPtr->dispPtr;
 
-    handler = Tk_CreateErrorHandler(wrapperPtr->display, -1, -1, -1,
-	    (Tk_ErrorProc *) NULL, (ClientData) NULL);
+    handler = Tk_CreateErrorHandler(wrapperPtr->display, -1,-1,-1, NULL,NULL);
     (void) XTranslateCoordinates(wrapperPtr->display, wrapperPtr->window,
 	    wmPtr->reparent, 0, 0, &xOffset, &yOffset, &dummy2);
     status = XGetGeometry(wrapperPtr->display, wmPtr->reparent,
@@ -3871,10 +3843,10 @@ ComputeReparentGeometry(wmPtr)
     Tk_DeleteErrorHandler(handler);
     if (status == 0) {
 	/*
-	 * It appears that the reparented parent went away and
-	 * no-one told us.  Reset the window to indicate that
-	 * it's not reparented.
+	 * It appears that the reparented parent went away and no-one told us.
+	 * Reset the window to indicate that it's not reparented.
 	 */
+
 	wmPtr->reparent = None;
 	wmPtr->xInParent = wmPtr->yInParent = 0;
 	return 0;
@@ -3887,28 +3859,27 @@ ComputeReparentGeometry(wmPtr)
     /*
      * Some tricky issues in updating wmPtr->x and wmPtr->y:
      *
-     * 1. Don't update them if the event occurred because of something
-     * we did (i.e. WM_SYNC_PENDING and WM_MOVE_PENDING are both set).
-     * This is because window managers treat coords differently than Tk,
-     * and no two window managers are alike. If the window manager moved
-     * the window because we told it to, remember the coordinates we told
-     * it, not the ones it actually moved it to.  This allows us to move
-     * the window back to the same coordinates later and get the same
-     * result. Without this check, windows can "walk" across the screen
-     * under some conditions.
+     * 1. Don't update them if the event occurred because of something we did
+     * (i.e. WM_SYNC_PENDING and WM_MOVE_PENDING are both set). This is
+     * because window managers treat coords differently than Tk, and no two
+     * window managers are alike. If the window manager moved the window
+     * because we told it to, remember the coordinates we told it, not the
+     * ones it actually moved it to. This allows us to move the window back to
+     * the same coordinates later and get the same result. Without this check,
+     * windows can "walk" across the screen under some conditions.
      *
-     * 2. Don't update wmPtr->x and wmPtr->y unless wrapperPtr->changes.x
-     * or wrapperPtr->changes.y has changed (otherwise a size change can
-     * spoof us into thinking that the position changed too and defeat
-     * the intent of (1) above.
+     * 2. Don't update wmPtr->x and wmPtr->y unless wrapperPtr->changes.x or
+     * wrapperPtr->changes.y has changed (otherwise a size change can spoof us
+     * into thinking that the position changed too and defeat the intent of
+     * (1) above.
      *
-     * (As of 9/96 the above 2 comments appear to be stale.  They're
-     * being left in place as a reminder of what was once true (and
-     * perhaps should still be true?)).
+     * (As of 9/96 the above 2 comments appear to be stale. They're being left
+     * in place as a reminder of what was once true (and perhaps should still
+     * be true?)).
      *
-     * 3. Ignore size changes coming from the window system if we're
-     * about to change the size ourselves but haven't seen the event for
-     * it yet:  our size change is supposed to take priority.
+     * 3. Ignore size changes coming from the window system if we're about to
+     * change the size ourselves but haven't seen the event for it yet: our
+     * size change is supposed to take priority.
      */
 
     if (!(wmPtr->flags & WM_MOVE_PENDING)
@@ -3940,23 +3911,23 @@ ComputeReparentGeometry(wmPtr)
  *
  * WrapperEventProc --
  *
- *	This procedure is invoked by the event loop when a wrapper window
- *	is restructured.
+ *	This function is invoked by the event loop when a wrapper window is
+ *	restructured.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Tk's internal data structures for the window get modified to
- *	reflect the structural change.
+ *	Tk's internal data structures for the window get modified to reflect
+ *	the structural change.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-WrapperEventProc(clientData, eventPtr)
-    ClientData clientData;		/* Information about toplevel window. */
-    XEvent *eventPtr;			/* Event that just happened. */
+WrapperEventProc(
+    ClientData clientData,	/* Information about toplevel window. */
+    XEvent *eventPtr)		/* Event that just happened. */
 {
     WmInfo *wmPtr = (WmInfo *) clientData;
     XEvent mapEvent;
@@ -3969,14 +3940,14 @@ WrapperEventProc(clientData, eventPtr)
 	if (!(wmPtr->wrapperPtr->flags & TK_ALREADY_DEAD)) {
 	    /*
 	     * A top-level window was deleted externally (e.g., by the window
-	     * manager).  This is probably not a good thing, but cleanup as
-	     * best we can.  The error handler is needed because
+	     * manager). This is probably not a good thing, but cleanup as
+	     * best we can. The error handler is needed because
 	     * Tk_DestroyWindow will try to destroy the window, but of course
 	     * it's already gone.
 	     */
 
 	    handler = Tk_CreateErrorHandler(wmPtr->winPtr->display, -1, -1, -1,
-		    (Tk_ErrorProc *) NULL, (ClientData) NULL);
+		    NULL, NULL);
 	    Tk_DestroyWindow((Tk_Window) wmPtr->winPtr);
 	    Tk_DeleteErrorHandler(handler);
 	}
@@ -3985,13 +3956,12 @@ WrapperEventProc(clientData, eventPtr)
 	}
     } else if (eventPtr->type == ConfigureNotify) {
 	/*
-	 * Ignore the event if the window has never been mapped yet.
-	 * Such an event occurs only in weird cases like changing the
-	 * internal border width of a top-level window, which results
-	 * in a synthetic Configure event.  These events are not relevant
-	 * to us, and if we process them confusion may result (e.g. we
-	 * may conclude erroneously that the user repositioned or resized
-	 * the window).
+	 * Ignore the event if the window has never been mapped yet. Such an
+	 * event occurs only in weird cases like changing the internal border
+	 * width of a top-level window, which results in a synthetic Configure
+	 * event. These events are not relevant to us, and if we process them
+	 * confusion may result (e.g. we may conclude erroneously that the
+	 * user repositioned or resized the window).
 	 */
 
 	if (!(wmPtr->flags & WM_NEVER_MAPPED)) {
@@ -4012,7 +3982,7 @@ WrapperEventProc(clientData, eventPtr)
     }
     return;
 
-    doMapEvent:
+  doMapEvent:
     mapEvent = *eventPtr;
     mapEvent.xmap.event = wmPtr->winPtr->window;
     mapEvent.xmap.window = wmPtr->winPtr->window;
@@ -4024,24 +3994,24 @@ WrapperEventProc(clientData, eventPtr)
  *
  * TopLevelReqProc --
  *
- *	This procedure is invoked by the geometry manager whenever
- *	the requested size for a top-level window is changed.
+ *	This function is invoked by the geometry manager whenever the
+ *	requested size for a top-level window is changed.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Arrange for the window to be resized to satisfy the request
- *	(this happens as a when-idle action).
+ *	Arrange for the window to be resized to satisfy the request (this
+ *	happens as a when-idle action).
  *
  *----------------------------------------------------------------------
  */
 
 	/* ARGSUSED */
 static void
-TopLevelReqProc(dummy, tkwin)
-    ClientData dummy;			/* Not used. */
-    Tk_Window tkwin;			/* Information about window. */
+TopLevelReqProc(
+    ClientData dummy,		/* Not used. */
+    Tk_Window tkwin)		/* Information about window. */
 {
     TkWindow *winPtr = (TkWindow *) tkwin;
     WmInfo *wmPtr;
@@ -4050,16 +4020,15 @@ TopLevelReqProc(dummy, tkwin)
 
     if ((wmPtr->width >= 0) && (wmPtr->height >= 0)) {
 	/*
-	 * Explicit dimensions have been set for this window, so we
-	 * should ignore the geometry request.  It's actually important
-	 * to ignore the geometry request because, due to quirks in
-	 * window managers, invoking UpdateGeometryInfo may cause the
-	 * window to move.  For example, if "wm geometry -10-20" was
-	 * invoked, the window may be positioned incorrectly the first
-	 * time it appears (because we didn't know the proper width of
-	 * the window manager borders); if we invoke UpdateGeometryInfo
-	 * again, the window will be positioned correctly, which may
-	 * cause it to jump on the screen.
+	 * Explicit dimensions have been set for this window, so we should
+	 * ignore the geometry request. It's actually important to ignore the
+	 * geometry request because, due to quirks in window managers,
+	 * invoking UpdateGeometryInfo may cause the window to move. For
+	 * example, if "wm geometry -10-20" was invoked, the window may be
+	 * positioned incorrectly the first time it appears (because we didn't
+	 * know the proper width of the window manager borders); if we invoke
+	 * UpdateGeometryInfo again, the window will be positioned correctly,
+	 * which may cause it to jump on the screen.
 	 */
 
 	return;
@@ -4072,8 +4041,8 @@ TopLevelReqProc(dummy, tkwin)
     }
 
     /*
-     * If the window isn't being positioned by its upper left corner
-     * then we have to move it as well.
+     * If the window isn't being positioned by its upper left corner then we
+     * have to move it as well.
      */
 
     if (wmPtr->flags & (WM_NEGATIVE_X | WM_NEGATIVE_Y)) {
@@ -4086,26 +4055,25 @@ TopLevelReqProc(dummy, tkwin)
  *
  * UpdateGeometryInfo --
  *
- *	This procedure is invoked when a top-level window is first
- *	mapped, and also as a when-idle procedure, to bring the
- *	geometry and/or position of a top-level window back into
- *	line with what has been requested by the user and/or widgets.
- *	This procedure doesn't return until the window manager has
- *	responded to the geometry change.
+ *	This function is invoked when a top-level window is first mapped, and
+ *	also as a when-idle function, to bring the geometry and/or position of
+ *	a top-level window back into line with what has been requested by the
+ *	user and/or widgets. This function doesn't return until the window
+ *	manager has responded to the geometry change.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The size and location of both the toplevel window and its wrapper
- *	may change, unless the WM prevents that from happening.
+ *	The size and location of both the toplevel window and its wrapper may
+ *	change, unless the WM prevents that from happening.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-UpdateGeometryInfo(clientData)
-    ClientData clientData;		/* Pointer to the window's record. */
+UpdateGeometryInfo(
+    ClientData clientData)	/* Pointer to the window's record. */
 {
     register TkWindow *winPtr = (TkWindow *) clientData;
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
@@ -4115,15 +4083,13 @@ UpdateGeometryInfo(clientData)
     wmPtr->flags &= ~WM_UPDATE_PENDING;
 
     /*
-     * Compute the new size for the top-level window.  See the
-     * user documentation for details on this, but the size
-     * requested depends on (a) the size requested internally
-     * by the window's widgets, (b) the size requested by the
-     * user in a "wm geometry" command or via wm-based interactive
-     * resizing (if any), (c) whether or not the window is
-     * gridded, and (d) the current min or max size for
-     * the toplevel. Don't permit sizes <= 0 because this
-     * upsets the X server.
+     * Compute the new size for the top-level window. See the user
+     * documentation for details on this, but the size requested depends on
+     * (a) the size requested internally by the window's widgets, (b) the size
+     * requested by the user in a "wm geometry" command or via wm-based
+     * interactive resizing (if any), (c) whether or not the window is
+     * gridded, and (d) the current min or max size for the toplevel. Don't
+     * permit sizes <= 0 because this upsets the X server.
      */
 
     if (wmPtr->width == -1) {
@@ -4137,9 +4103,11 @@ UpdateGeometryInfo(clientData)
     if (width <= 0) {
 	width = 1;
     }
+
     /*
      * Account for window max/min width
      */
+
     if (wmPtr->gridWin != NULL) {
 	min = winPtr->reqWidth
 		+ (wmPtr->minWidth - wmPtr->reqGridWidth)*wmPtr->widthInc;
@@ -4170,9 +4138,11 @@ UpdateGeometryInfo(clientData)
     if (height <= 0) {
 	height = 1;
     }
+
     /*
      * Account for window max/min height
      */
+
     if (wmPtr->gridWin != NULL) {
 	min = winPtr->reqHeight
 		+ (wmPtr->minHeight - wmPtr->reqGridHeight)*wmPtr->heightInc;
@@ -4194,30 +4164,30 @@ UpdateGeometryInfo(clientData)
 
     /*
      * Compute the new position for the upper-left pixel of the window's
-     * decorative frame.  This is tricky, because we need to include the
-     * border widths supplied by a reparented parent in this calculation,
-     * but can't use the parent's current overall size since that may
-     * change as a result of this code.
+     * decorative frame. This is tricky, because we need to include the border
+     * widths supplied by a reparented parent in this calculation, but can't
+     * use the parent's current overall size since that may change as a result
+     * of this code.
      */
 
     if (wmPtr->flags & WM_NEGATIVE_X) {
 	x = wmPtr->vRootWidth - wmPtr->x
 		- (width + (wmPtr->parentWidth - winPtr->changes.width));
     } else {
-	x =  wmPtr->x;
+	x = wmPtr->x;
     }
     if (wmPtr->flags & WM_NEGATIVE_Y) {
 	y = wmPtr->vRootHeight - wmPtr->y
 		- (height + (wmPtr->parentHeight - winPtr->changes.height));
     } else {
-	y =  wmPtr->y;
+	y = wmPtr->y;
     }
 
     /*
-     * If the window's size is going to change and the window is
-     * supposed to not be resizable by the user, then we have to
-     * update the size hints.  There may also be a size-hint-update
-     * request pending from somewhere else, too.
+     * If the window's size is going to change and the window is supposed to
+     * not be resizable by the user, then we have to update the size hints.
+     * There may also be a size-hint-update request pending from somewhere
+     * else, too.
      */
 
     if (((width != winPtr->changes.width)
@@ -4231,35 +4201,34 @@ UpdateGeometryInfo(clientData)
     }
 
     /*
-     * Reconfigure the wrapper if it isn't already configured correctly.
-     * A few tricky points:
+     * Reconfigure the wrapper if it isn't already configured correctly. A few
+     * tricky points:
      *
-     * 1. If the window is embeddedand the container is also in this
-     *    process, don't actually reconfigure the window; just pass the
-     *    desired size on to the container.  Also, zero out any position
-     *    information, since embedded windows are not allowed to move.
-     * 2. Sometimes the window manager will give us a different size
-     *    than we asked for (e.g. mwm has a minimum size for windows), so
-     *    base the size check on what we *asked for* last time, not what we
-     *    got.
+     * 1. If the window is embeddedand the container is also in this process,
+     *    don't actually reconfigure the window; just pass the desired size on
+     *    to the container. Also, zero out any position information, since
+     *    embedded windows are not allowed to move.
+     * 2. Sometimes the window manager will give us a different size than we
+     *    asked for (e.g. mwm has a minimum size for windows), so base the
+     *    size check on what we *asked for* last time, not what we got.
      * 3. Can't just reconfigure always, because we may not get a
      *    ConfigureNotify event back if nothing changed, so
      *    WaitForConfigureNotify will hang a long time.
-     * 4. Don't move window unless a new position has been requested for
-     *	  it.  This is because of "features" in some window managers (e.g.
-     *    twm, as of 4/24/91) where they don't interpret coordinates
-     *    according to ICCCM.  Moving a window to its current location may
-     *    cause it to shift position on the screen.
+     * 4. Don't move window unless a new position has been requested for it.
+     *	  This is because of "features" in some window managers (e.g. twm, as
+     *	  of 4/24/91) where they don't interpret coordinates according to
+     *	  ICCCM. Moving a window to its current location may cause it to shift
+     *	  position on the screen.
      */
 
     if ((winPtr->flags & (TK_EMBEDDED|TK_BOTH_HALVES))
 	    == (TK_EMBEDDED|TK_BOTH_HALVES)) {
 	/*
-	 * This window is embedded and the container is also in this
-	 * process, so we don't need to do anything special about the
-	 * geometry, except to make sure that the desired size is known
-	 * by the container.  Also, zero out any position information,
-	 * since embedded windows are not allowed to move.
+	 * This window is embedded and the container is also in this process,
+	 * so we don't need to do anything special about the geometry, except
+	 * to make sure that the desired size is known by the container. Also,
+	 * zero out any position information, since embedded windows are not
+	 * allowed to move.
 	 */
 
 	wmPtr->x = wmPtr->y = 0;
@@ -4277,9 +4246,9 @@ UpdateGeometryInfo(clientData)
 		&& (width == wmPtr->wrapperPtr->changes.width)
 		&& (height == wmPtr->wrapperPtr->changes.height)) {
 	    /*
-	     * The window already has the correct geometry, so don't bother
-	     * to configure it;  the X server appears to ignore these
-	     * requests, so we won't get back a ConfigureNotify and the
+	     * The window already has the correct geometry, so don't bother to
+	     * configure it; the X server appears to ignore these requests, so
+	     * we won't get back a ConfigureNotify and the
 	     * WaitForConfigureNotify call below will hang for a while.
 	     */
 
@@ -4289,8 +4258,8 @@ UpdateGeometryInfo(clientData)
 	wmPtr->configWidth = width;
 	wmPtr->configHeight = height;
 	if (winPtr->dispPtr->flags & TK_DISPLAY_WM_TRACING) {
-	   printf("UpdateGeometryInfo moving to %d %d, resizing to %d x %d,\n",
-                   x, y, width, height);
+	    printf("UpdateGeometryInfo moving to %d %d, resizing to %dx%d,\n",
+		    x, y, width, height);
 	}
 	XMoveResizeWindow(winPtr->display, wmPtr->wrapperPtr->window, x, y,
 		(unsigned) width, (unsigned) height);
@@ -4299,9 +4268,9 @@ UpdateGeometryInfo(clientData)
 	if ((width == wmPtr->wrapperPtr->changes.width)
 		&& (height == wmPtr->wrapperPtr->changes.height)) {
 	    /*
-	     * The window is already just the size we want, so don't bother
-	     * to configure it;  the X server appears to ignore these
-	     * requests, so we won't get back a ConfigureNotify and the
+	     * The window is already just the size we want, so don't bother to
+	     * configure it; the X server appears to ignore these requests, so
+	     * we won't get back a ConfigureNotify and the
 	     * WaitForConfigureNotify call below will hang for a while.
 	     */
 
@@ -4319,8 +4288,8 @@ UpdateGeometryInfo(clientData)
 	    && ((Tk_Width(wmPtr->menubar) != wmPtr->wrapperPtr->changes.width)
 	    || (Tk_Height(wmPtr->menubar) != wmPtr->menuHeight))) {
 	/*
-	 * It is possible that the window's overall size has not changed
-	 * but the menu size has.
+	 * It is possible that the window's overall size has not changed but
+	 * the menu size has.
 	 */
 
 	Tk_MoveResizeWindow(wmPtr->menubar, 0, 0,
@@ -4332,9 +4301,9 @@ UpdateGeometryInfo(clientData)
     }
 
     /*
-     * Wait for the configure operation to complete.  Don't need to do
-     * this, however, if the window is about to be mapped:  it will be
-     * taken care of elsewhere.
+     * Wait for the configure operation to complete. Don't need to do this,
+     * however, if the window is about to be mapped: it will be taken care of
+     * elsewhere.
      */
 
     if (!(wmPtr->flags & WM_ABOUT_TO_MAP)) {
@@ -4347,9 +4316,8 @@ UpdateGeometryInfo(clientData)
  *
  * UpdateSizeHints --
  *
- *	This procedure is called to update the window manager's
- *	size hints information from the information in a WmInfo
- *	structure.
+ *	This function is called to update the window manager's size hints
+ *	information from the information in a WmInfo structure.
  *
  * Results:
  *	None.
@@ -4361,10 +4329,10 @@ UpdateGeometryInfo(clientData)
  */
 
 static void
-UpdateSizeHints(winPtr, newWidth, newHeight)
-    TkWindow *winPtr;
-    int newWidth;
-    int newHeight;
+UpdateSizeHints(
+    TkWindow *winPtr,
+    int newWidth,
+    int newHeight)
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     XSizeHints *hintsPtr;
@@ -4378,9 +4346,8 @@ UpdateSizeHints(winPtr, newWidth, newHeight)
     }
 
     /*
-     * Compute the pixel-based sizes for the various fields in the
-     * size hints structure, based on the grid-based sizes in
-     * our structure.
+     * Compute the pixel-based sizes for the various fields in the size hints
+     * structure, based on the grid-based sizes in our structure.
      */
 
     GetMaxSize(wmPtr, &maxWidth, &maxHeight);
@@ -4421,18 +4388,18 @@ UpdateSizeHints(winPtr, newWidth, newHeight)
     hintsPtr->flags = wmPtr->sizeHintsFlags | PMinSize;
 
     /*
-     * If the window isn't supposed to be resizable, then set the
-     * minimum and maximum dimensions to be the same.
+     * If the window isn't supposed to be resizable, then set the minimum and
+     * maximum dimensions to be the same.
      */
 
     if (wmPtr->flags & WM_WIDTH_NOT_RESIZABLE) {
 	hintsPtr->max_width = hintsPtr->min_width = newWidth;
-    	hintsPtr->flags |= PMaxSize;
+	hintsPtr->flags |= PMaxSize;
     }
     if (wmPtr->flags & WM_HEIGHT_NOT_RESIZABLE) {
 	hintsPtr->max_height = hintsPtr->min_height =
-	    newHeight + wmPtr->menuHeight;
-    	hintsPtr->flags |= PMaxSize;
+		newHeight + wmPtr->menuHeight;
+	hintsPtr->flags |= PMaxSize;
     }
 
     XSetWMNormalHints(winPtr->display, wmPtr->wrapperPtr->window, hintsPtr);
@@ -4445,27 +4412,26 @@ UpdateSizeHints(winPtr, newWidth, newHeight)
  *
  * UpdateTitle --
  *
- *	This procedure is called to update the window title and 
- *	icon name.  It sets the ICCCM-defined properties WM_NAME
- *	and WM_ICON_NAME for older window managers, and the 
- *	freedesktop.org-defined _NET_WM_NAME and _NET_WM_ICON_NAME
- *	properties for newer ones.  The ICCCM properties are
- *	stored in the system encoding, the newer properties
- *	are stored in UTF-8.
+ *	This function is called to update the window title and icon name. It
+ *	sets the ICCCM-defined properties WM_NAME and WM_ICON_NAME for older
+ *	window managers, and the freedesktop.org-defined _NET_WM_NAME and
+ *	_NET_WM_ICON_NAME properties for newer ones. The ICCCM properties are
+ *	stored in the system encoding, the newer properties are stored in
+ *	UTF-8.
  *
- *	NOTE: the ICCCM specifies that WM_NAME and WM_ICON_NAME are 
- *	stored in ISO-Latin-1.  Tk has historically used the default 
- *	system encoding (since 8.1).  It's not clear whether this is 
- *	correct or not.
+ *	NOTE: the ICCCM specifies that WM_NAME and WM_ICON_NAME are stored in
+ *	ISO-Latin-1. Tk has historically used the default system encoding
+ *	(since 8.1). It's not clear whether this is correct or not.
  *
  * Side effects:
  *	Properties get changed for winPtr.
  *
  *--------------------------------------------------------------
  */
+
 static void
-UpdateTitle(winPtr)
-    TkWindow *winPtr;
+UpdateTitle(
+    TkWindow *winPtr)
 {
     WmInfo *wmPtr = winPtr->wmInfoPtr;
     Atom XA_UTF8_STRING = Tk_InternAtom((Tk_Window) winPtr, "UTF8_STRING");
@@ -4475,6 +4441,7 @@ UpdateTitle(winPtr)
     /*
      * Set window title:
      */
+
     string = (wmPtr->title != NULL) ? wmPtr->title : winPtr->nameUid;
     Tcl_UtfToExternalDString(NULL, string, -1, &ds);
     XStoreName(winPtr->display, wmPtr->wrapperPtr->window,
@@ -4483,12 +4450,13 @@ UpdateTitle(winPtr)
 
     XChangeProperty(winPtr->display, wmPtr->wrapperPtr->window,
 	    Tk_InternAtom((Tk_Window) winPtr, "_NET_WM_NAME"),
-	    XA_UTF8_STRING, 8, PropModeReplace, 
+	    XA_UTF8_STRING, 8, PropModeReplace,
 	    (const unsigned char*)string, (signed int)strlen(string));
 
     /*
      * Set icon name:
      */
+
     if (wmPtr->iconName != NULL) {
 	Tcl_UtfToExternalDString(NULL, wmPtr->iconName, -1, &ds);
 	XSetIconName(winPtr->display, wmPtr->wrapperPtr->window,
@@ -4508,17 +4476,18 @@ UpdateTitle(winPtr)
  *
  * UpdatePhotoIcon --
  *
- *	This procedure is called to update the window ohoto icon.
- *	It sets the EWMH-defined properties _NET_WM_ICON.
+ *	This function is called to update the window photo icon. It sets the
+ *	EWMH-defined properties _NET_WM_ICON.
  *
  * Side effects:
  *	Properties get changed for winPtr.
  *
  *--------------------------------------------------------------
  */
+
 static void
-UpdatePhotoIcon(winPtr)
-    TkWindow *winPtr;
+UpdatePhotoIcon(
+    TkWindow *winPtr)
 {
     WmInfo *wmPtr = winPtr->wmInfoPtr;
     unsigned char *data = wmPtr->iconDataPtr;
@@ -4532,6 +4501,7 @@ UpdatePhotoIcon(winPtr)
 	/*
 	 * Set icon:
 	 */
+
 	XChangeProperty(winPtr->display, wmPtr->wrapperPtr->window,
 		Tk_InternAtom((Tk_Window) winPtr, "_NET_WM_ICON"),
 		XA_CARDINAL, 32, PropModeReplace,
@@ -4544,48 +4514,47 @@ UpdatePhotoIcon(winPtr)
  *
  * WaitForConfigureNotify --
  *
- *	This procedure is invoked in order to synchronize with the
- *	window manager.  It waits for a ConfigureNotify event to
- *	arrive, signalling that the window manager has seen an attempt
- *	on our part to move or resize a top-level window.
+ *	This function is invoked in order to synchronize with the window
+ *	manager. It waits for a ConfigureNotify event to arrive, signalling
+ *	that the window manager has seen an attempt on our part to move or
+ *	resize a top-level window.
  *
  * Results:
  *	None.
  *
  * Side effects:
  *	Delays the execution of the process until a ConfigureNotify event
- *	arrives with serial number at least as great as serial.  This
- *	is useful for two reasons:
+ *	arrives with serial number at least as great as serial. This is useful
+ *	for two reasons:
  *
  *	1. It's important to distinguish ConfigureNotify events that are
  *	   coming in response to a request we've made from those generated
- *	   spontaneously by the user.  The reason for this is that if the
- *	   user resizes the window we take that as an order to ignore
- *	   geometry requests coming from inside the window hierarchy.  If
- *	   we accidentally interpret a response to our request as a
- *	   user-initiated action, the window will stop responding to
- *	   new geometry requests.  To make this distinction, (a) this
- *	   procedure sets a flag for TopLevelEventProc to indicate that
- *	   we're waiting to sync with the wm, and (b) all changes to
- *	   the size of a top-level window are followed by calls to this
- *	   procedure.
- *	2. Races and confusion can come about if there are multiple
- *	   operations outstanding at a time (e.g. two different resizes
- *	   of the top-level window:  it's hard to tell which of the
- *	   ConfigureNotify events coming back is for which request).
+ *	   spontaneously by the user. The reason for this is that if the user
+ *	   resizes the window we take that as an order to ignore geometry
+ *	   requests coming from inside the window hierarchy. If we
+ *	   accidentally interpret a response to our request as a
+ *	   user-initiated action, the window will stop responding to new
+ *	   geometry requests. To make this distinction, (a) this function sets
+ *	   a flag for TopLevelEventProc to indicate that we're waiting to sync
+ *	   with the wm, and (b) all changes to the size of a top-level window
+ *	   are followed by calls to this function.
+ *	2. Races and confusion can come about if there are multiple operations
+ *	   outstanding at a time (e.g. two different resizes of the top-level
+ *	   window: it's hard to tell which of the ConfigureNotify events
+ *	   coming back is for which request).
  *	While waiting, some events covered by StructureNotifyMask are
- *	processed (ConfigureNotify, MapNotify, and UnmapNotify) 
- *	and all others are deferred.
+ *	processed (ConfigureNotify, MapNotify, and UnmapNotify) and all others
+ *	are deferred.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-WaitForConfigureNotify(winPtr, serial)
-    TkWindow *winPtr;		/* Top-level window for which we want
-				 * to see a ConfigureNotify. */
-    unsigned long serial;	/* Serial number of resize request.  Want to
-				 * be sure wm has seen this. */
+WaitForConfigureNotify(
+    TkWindow *winPtr,		/* Top-level window for which we want to see a
+				 * ConfigureNotify. */
+    unsigned long serial)	/* Serial number of resize request. Want to be
+				 * sure wm has seen this. */
 {
     WmInfo *wmPtr = winPtr->wmInfoPtr;
     XEvent event;
@@ -4593,11 +4562,10 @@ WaitForConfigureNotify(winPtr, serial)
     int gotConfig = 0;
 
     /*
-     * One more tricky detail about this procedure.  In some cases the
-     * window manager will decide to ignore a configure request (e.g.
-     * because it thinks the window is already in the right place).
-     * To avoid hanging in this situation, only wait for a few seconds,
-     * then give up.
+     * One more tricky detail about this function. In some cases the window
+     * manager will decide to ignore a configure request (e.g. because it
+     * thinks the window is already in the right place). To avoid hanging in
+     * this situation, only wait for a few seconds, then give up.
      */
 
     while (!gotConfig) {
@@ -4628,32 +4596,31 @@ WaitForConfigureNotify(winPtr, serial)
  *
  * WaitForEvent --
  *
- *	This procedure is used by WaitForConfigureNotify and
- *	WaitForMapNotify to wait for an event of a certain type
- *	to arrive.
+ *	This function is used by WaitForConfigureNotify and WaitForMapNotify
+ *	to wait for an event of a certain type to arrive.
  *
  * Results:
- *	Under normal conditions, TCL_OK is returned and an event for
- *	display and window that matches "mask" is stored in *eventPtr.
- *	This event  has already been processed by Tk before this procedure
- *	returns.  If a long time goes by with no event of the right type
- *	arriving, or if an error occurs while waiting for the event to
- *	arrive, then TCL_ERROR is returned.
+ *	Under normal conditions, TCL_OK is returned and an event for display
+ *	and window that matches "mask" is stored in *eventPtr. This event has
+ *	already been processed by Tk before this function returns. If a long
+ *	time goes by with no event of the right type arriving, or if an error
+ *	occurs while waiting for the event to arrive, then TCL_ERROR is
+ *	returned.
  *
  * Side effects:
  *	While waiting for the desired event to occur, Configurenotify,
- *	MapNotify, and UnmapNotify events for window are processed, 
- *	as are all ReparentNotify events.
+ *	MapNotify, and UnmapNotify events for window are processed, as are all
+ *	ReparentNotify events.
  *
  *----------------------------------------------------------------------
  */
 
 static int
-WaitForEvent(display, wmInfoPtr, type, eventPtr)
-    Display *display;		/* Display event is coming from. */
-    WmInfo *wmInfoPtr;		/* Window for which event is desired. */
-    int type;			/* Type of event that is wanted. */
-    XEvent *eventPtr;		/* Place to store event. */
+WaitForEvent(
+    Display *display,		/* Display event is coming from. */
+    WmInfo *wmInfoPtr,		/* Window for which event is desired. */
+    int type,			/* Type of event that is wanted. */
+    XEvent *eventPtr)		/* Place to store event. */
 {
     WaitRestrictInfo info;
     Tk_RestrictProc *oldRestrictProc;
@@ -4661,9 +4628,9 @@ WaitForEvent(display, wmInfoPtr, type, eventPtr)
     Tcl_Time timeout;
 
     /*
-     * Set up an event filter to select just the events we want, and
-     * a timer handler, then wait for events until we get the event
-     * we want or a timeout happens.
+     * Set up an event filter to select just the events we want, and a timer
+     * handler, then wait for events until we get the event we want or a
+     * timeout happens.
      */
 
     info.display = display;
@@ -4695,26 +4662,26 @@ WaitForEvent(display, wmInfoPtr, type, eventPtr)
  *
  * WaitRestrictProc --
  *
- *	This procedure is a Tk_RestrictProc that is used to filter
- *	events while WaitForEvent is active.
+ *	This function is a Tk_RestrictProc that is used to filter events while
+ *	WaitForEvent is active.
  *
  * Results:
- *	Returns TK_PROCESS_EVENT if the right event is found.  Also
- *	returns TK_PROCESS_EVENT if any ReparentNotify event is found
- *	or if the event is a ConfigureNotify, MapNotify, or UnmapNotify
- *	for window.  Otherwise returns TK_DEFER_EVENT.
+ *	Returns TK_PROCESS_EVENT if the right event is found. Also returns
+ *	TK_PROCESS_EVENT if any ReparentNotify event is found or if the event
+ *	is a ConfigureNotify, MapNotify, or UnmapNotify for window. Otherwise
+ *	returns TK_DEFER_EVENT.
  *
  * Side effects:
- *	An event may get stored in the area indicated by the caller
- *	of WaitForEvent.
+ *	An event may get stored in the area indicated by the caller of
+ *	WaitForEvent.
  *
  *----------------------------------------------------------------------
  */
 
 static Tk_RestrictAction
-WaitRestrictProc(clientData, eventPtr)
-    ClientData clientData;	/* Pointer to WaitRestrictInfo structure. */
-    XEvent *eventPtr;		/* Event that is about to be handled. */
+WaitRestrictProc(
+    ClientData clientData,	/* Pointer to WaitRestrictInfo structure. */
+    XEvent *eventPtr)		/* Event that is about to be handled. */
 {
     WaitRestrictInfo *infoPtr = (WaitRestrictInfo *) clientData;
 
@@ -4731,9 +4698,8 @@ WaitRestrictProc(clientData, eventPtr)
 	infoPtr->foundEvent = 1;
 	return TK_PROCESS_EVENT;
     }
-    if (eventPtr->type == ConfigureNotify 
-	   || eventPtr->type == MapNotify
-	   || eventPtr->type == UnmapNotify) {
+    if (eventPtr->type == ConfigureNotify || eventPtr->type == MapNotify
+	    || eventPtr->type == UnmapNotify) {
 	return TK_PROCESS_EVENT;
     }
     return TK_DEFER_EVENT;
@@ -4744,32 +4710,31 @@ WaitRestrictProc(clientData, eventPtr)
  *
  * WaitForMapNotify --
  *
- *	This procedure is invoked in order to synchronize with the
- *	window manager.  It waits for the window's mapped state to
- *	reach the value given by mapped.
+ *	This function is invoked in order to synchronize with the window
+ *	manager. It waits for the window's mapped state to reach the value
+ *	given by mapped.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Delays the execution of the process until winPtr becomes mapped
- *	or unmapped, depending on the "mapped" argument.  This allows us
- *	to synchronize with the window manager, and allows us to
- *	identify changes in window size that come about when the window
- *	manager first starts managing the window (as opposed to those
- *	requested interactively by the user later).  See the comments
- *	for WaitForConfigureNotify and WM_SYNC_PENDING.  While waiting,
- *	some events covered by StructureNotifyMask are processed and all
- *	others are deferred.
+ *	Delays the execution of the process until winPtr becomes mapped or
+ *	unmapped, depending on the "mapped" argument. This allows us to
+ *	synchronize with the window manager, and allows us to identify changes
+ *	in window size that come about when the window manager first starts
+ *	managing the window (as opposed to those requested interactively by
+ *	the user later). See the comments for WaitForConfigureNotify and
+ *	WM_SYNC_PENDING. While waiting, some events covered by
+ *	StructureNotifyMask are processed and all others are deferred.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-WaitForMapNotify(winPtr, mapped)
-    TkWindow *winPtr;		/* Top-level window for which we want
-				 * to see a particular mapping state. */
-    int mapped;			/* If non-zero, wait for window to become
+WaitForMapNotify(
+    TkWindow *winPtr,		/* Top-level window for which we want to see a
+				 * particular mapping state. */
+    int mapped)			/* If non-zero, wait for window to become
 				 * mapped, otherwise wait for it to become
 				 * unmapped. */
 {
@@ -4791,10 +4756,9 @@ WaitForMapNotify(winPtr, mapped)
 	wmPtr->flags &= ~WM_SYNC_PENDING;
 	if (code != TCL_OK) {
 	    /*
-	     * There are some bizarre situations in which the window
-	     * manager can't respond or chooses not to (e.g. if we've
-	     * got a grab set it can't respond).  If this happens then
-	     * just quit.
+	     * There are some bizarre situations in which the window manager
+	     * can't respond or chooses not to (e.g. if we've got a grab set
+	     * it can't respond). If this happens then just quit.
 	     */
 
 	    if (winPtr->dispPtr->flags & TK_DISPLAY_WM_TRACING) {
@@ -4815,9 +4779,8 @@ WaitForMapNotify(winPtr, mapped)
  *
  * UpdateHints --
  *
- *	This procedure is called to update the window manager's
- *	hints information from the information in a WmInfo
- *	structure.
+ *	This function is called to update the window manager's hints
+ *	information from the information in a WmInfo structure.
  *
  * Results:
  *	None.
@@ -4829,8 +4792,8 @@ WaitForMapNotify(winPtr, mapped)
  */
 
 static void
-UpdateHints(winPtr)
-    TkWindow *winPtr;
+UpdateHints(
+    TkWindow *winPtr)
 {
     WmInfo *wmPtr = winPtr->wmInfoPtr;
 
@@ -4845,13 +4808,12 @@ UpdateHints(winPtr)
  *
  * ParseGeometry --
  *
- *	This procedure parses a geometry string and updates
- *	information used to control the geometry of a top-level
- *	window.
+ *	This function parses a geometry string and updates information used to
+ *	control the geometry of a top-level window.
  *
  * Results:
- *	A standard Tcl return value, plus an error message in
- *	the interp's result if an error occurs.
+ *	A standard Tcl return value, plus an error message in the interp's
+ *	result if an error occurs.
  *
  * Side effects:
  *	The size and/or location of winPtr may change.
@@ -4860,12 +4822,12 @@ UpdateHints(winPtr)
  */
 
 static int
-ParseGeometry(interp, string, winPtr)
-    Tcl_Interp *interp;		/* Used for error reporting. */
-    char *string;		/* String containing new geometry.  Has the
+ParseGeometry(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    char *string,		/* String containing new geometry. Has the
 				 * standard form "=wxh+x+y". */
-    TkWindow *winPtr;		/* Pointer to top-level window whose
-				 * geometry is to be changed. */
+    TkWindow *winPtr)		/* Pointer to top-level window whose geometry
+				 * is to be changed. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     int x, y, width, height, flags;
@@ -4881,9 +4843,9 @@ ParseGeometry(interp, string, winPtr)
     }
 
     /*
-     * Parse the width and height, if they are present.  Don't
-     * actually update any of the fields of wmPtr until we've
-     * successfully parsed the entire geometry string.
+     * Parse the width and height, if they are present. Don't actually update
+     * any of the fields of wmPtr until we've successfully parsed the entire
+     * geometry string.
      */
 
     width = wmPtr->width;
@@ -4937,10 +4899,10 @@ ParseGeometry(interp, string, winPtr)
 	}
 
 	/*
-	 * Assume that the geometry information came from the user,
-	 * unless an explicit source has been specified.  Otherwise
-	 * most window managers assume that the size hints were
-	 * program-specified and they ignore them.
+	 * Assume that the geometry information came from the user, unless an
+	 * explicit source has been specified. Otherwise most window managers
+	 * assume that the size hints were program-specified and they ignore
+	 * them.
 	 */
 
 	if ((wmPtr->sizeHintsFlags & (USPosition|PPosition)) == 0) {
@@ -4950,9 +4912,9 @@ ParseGeometry(interp, string, winPtr)
     }
 
     /*
-     * Everything was parsed OK.  Update the fields of *wmPtr and
-     * arrange for the appropriate information to be percolated out
-     * to the window manager at the next idle moment.
+     * Everything was parsed OK. Update the fields of *wmPtr and arrange for
+     * the appropriate information to be percolated out to the window manager
+     * at the next idle moment.
      */
 
     wmPtr->width = width;
@@ -4968,9 +4930,8 @@ ParseGeometry(interp, string, winPtr)
     }
     return TCL_OK;
 
-    error:
-    Tcl_AppendResult(interp, "bad geometry specifier \"",
-	    string, "\"", (char *) NULL);
+  error:
+    Tcl_AppendResult(interp, "bad geometry specifier \"", string, "\"", NULL);
     return TCL_ERROR;
 }
 
@@ -4979,15 +4940,15 @@ ParseGeometry(interp, string, winPtr)
  *
  * Tk_GetRootCoords --
  *
- *	Given a token for a window, this procedure traces through the
- *	window's lineage to find the (virtual) root-window coordinates
- *	corresponding to point (0,0) in the window.
+ *	Given a token for a window, this function traces through the window's
+ *	lineage to find the (virtual) root-window coordinates corresponding to
+ *	point (0,0) in the window.
  *
  * Results:
- *	The locations pointed to by xPtr and yPtr are filled in with
- *	the root coordinates of the (0,0) point in tkwin.  If a virtual
- *	root window is in effect for the window, then the coordinates
- *	in the virtual root are returned.
+ *	The locations pointed to by xPtr and yPtr are filled in with the root
+ *	coordinates of the (0,0) point in tkwin. If a virtual root window is
+ *	in effect for the window, then the coordinates in the virtual root are
+ *	returned.
  *
  * Side effects:
  *	None.
@@ -4996,18 +4957,17 @@ ParseGeometry(interp, string, winPtr)
  */
 
 void
-Tk_GetRootCoords(tkwin, xPtr, yPtr)
-    Tk_Window tkwin;		/* Token for window. */
-    int *xPtr;			/* Where to store x-displacement of (0,0). */
-    int *yPtr;			/* Where to store y-displacement of (0,0). */
+Tk_GetRootCoords(
+    Tk_Window tkwin,		/* Token for window. */
+    int *xPtr,			/* Where to store x-displacement of (0,0). */
+    int *yPtr)			/* Where to store y-displacement of (0,0). */
 {
     int x, y;
     register TkWindow *winPtr = (TkWindow *) tkwin;
 
     /*
-     * Search back through this window's parents all the way to a
-     * top-level window, combining the offsets of each window within
-     * its parent.
+     * Search back through this window's parents all the way to a top-level
+     * window, combining the offsets of each window within its parent.
      */
 
     x = y = 0;
@@ -5017,10 +4977,9 @@ Tk_GetRootCoords(tkwin, xPtr, yPtr)
 	if ((winPtr->wmInfoPtr != NULL)
 		&& (winPtr->wmInfoPtr->menubar == (Tk_Window) winPtr)) {
 	    /*
-	     * This window is a special menubar; switch over to its
-	     * associated toplevel, compensate for their differences in
-	     * y coordinates, then continue with the toplevel (in case
-	     * it's embedded).
+	     * This window is a special menubar; switch over to its associated
+	     * toplevel, compensate for their differences in y coordinates,
+	     * then continue with the toplevel (in case it's embedded).
 	     */
 
 	    y -= winPtr->wmInfoPtr->menuHeight;
@@ -5036,8 +4995,8 @@ Tk_GetRootCoords(tkwin, xPtr, yPtr)
 	    otherPtr = TkpGetOtherWindow(winPtr);
 	    if (otherPtr == NULL) {
 		/*
-		 * The container window is not in the same application.
-		 * Query the X server.
+		 * The container window is not in the same application. Query
+		 * the X server.
 		 */
 
 		Window root, dummyChild;
@@ -5048,14 +5007,14 @@ Tk_GetRootCoords(tkwin, xPtr, yPtr)
 		    root = RootWindowOfScreen(Tk_Screen((Tk_Window)winPtr));
 		}
 		XTranslateCoordinates(winPtr->display, winPtr->window,
-		    root, 0, 0, &rootX, &rootY, &dummyChild);
+			root, 0, 0, &rootX, &rootY, &dummyChild);
 		x += rootX;
 		y += rootY;
 		break;
 	    } else {
 		/*
-		 * The container window is in the same application.
-		 * Let's query its coordinates.
+		 * The container window is in the same application. Let's
+		 * query its coordinates.
 		 */
 
 		winPtr = otherPtr;
@@ -5076,13 +5035,13 @@ Tk_GetRootCoords(tkwin, xPtr, yPtr)
  *
  * Tk_CoordsToWindow --
  *
- *	Given the (virtual) root coordinates of a point, this procedure
- *	returns the token for the top-most window covering that point,
- *	if there exists such a window in this application.
+ *	Given the (virtual) root coordinates of a point, this function returns
+ *	the token for the top-most window covering that point, if there exists
+ *	such a window in this application.
  *
  * Results:
- *	The return result is either a token for the window corresponding
- *	to rootX and rootY, or else NULL to indicate that there is no such
+ *	The return result is either a token for the window corresponding to
+ *	rootX and rootY, or else NULL to indicate that there is no such
  *	window.
  *
  * Side effects:
@@ -5092,13 +5051,13 @@ Tk_GetRootCoords(tkwin, xPtr, yPtr)
  */
 
 Tk_Window
-Tk_CoordsToWindow(rootX, rootY, tkwin)
-    int rootX, rootY;		/* Coordinates of point in root window.  If
-				 * a virtual-root window manager is in use,
+Tk_CoordsToWindow(
+    int rootX, int rootY,	/* Coordinates of point in root window. If a
+				 * virtual-root window manager is in use,
 				 * these coordinates refer to the virtual
 				 * root, not the real root. */
-    Tk_Window tkwin;		/* Token for any window in application;
-				 * used to identify the display. */
+    Tk_Window tkwin)		/* Token for any window in application; used
+				 * to identify the display. */
 {
     Window window, parent, child;
     int x, y, childX, childY, tmpx, tmpy, bd;
@@ -5108,16 +5067,16 @@ Tk_CoordsToWindow(rootX, rootY, tkwin)
     Tk_ErrorHandler handler = NULL;
 
     /*
-     * Step 1: scan the list of toplevel windows to see if there is a
-     * virtual root for the screen we're interested in.  If so, we have
-     * to translate the coordinates from virtual root to root
-     * coordinates.
+     * Step 1: scan the list of toplevel windows to see if there is a virtual
+     * root for the screen we're interested in. If so, we have to translate
+     * the coordinates from virtual root to root coordinates.
      */
 
     parent = window = RootWindowOfScreen(Tk_Screen(tkwin));
     x = rootX;
     y = rootY;
-    for (wmPtr = (WmInfo *) dispPtr->firstWmPtr; wmPtr != NULL; wmPtr = wmPtr->nextPtr) {
+    for (wmPtr = (WmInfo *) dispPtr->firstWmPtr; wmPtr != NULL;
+	    wmPtr = wmPtr->nextPtr) {
 	if (Tk_Screen(wmPtr->winPtr) != Tk_Screen(tkwin)) {
 	    continue;
 	}
@@ -5130,29 +5089,28 @@ Tk_CoordsToWindow(rootX, rootY, tkwin)
     }
 
     /*
-     * Step 2: work down through the window hierarchy starting at the
-     * root. For each window, find the child that contains the given
-     * point and then see if this child is either a wrapper for one of
-     * our toplevel windows or a window manager decoration window for
-     * one of our toplevels.  This approach handles several tricky
-     * cases:
+     * Step 2: work down through the window hierarchy starting at the root.
+     * For each window, find the child that contains the given point and then
+     * see if this child is either a wrapper for one of our toplevel windows
+     * or a window manager decoration window for one of our toplevels. This
+     * approach handles several tricky cases:
      *
-     * 1. There may be a virtual root window between the root and one of
-     *    our toplevels.
+     * 1. There may be a virtual root window between the root and one of our
+     *    toplevels.
      * 2. If a toplevel is embedded, we may have to search through the
-     *    windows of the container application(s) before getting to
-     *    the toplevel.
+     *    windows of the container application(s) before getting to the
+     *    toplevel.
      */
 
-    handler = Tk_CreateErrorHandler(Tk_Display(tkwin), -1, -1, -1,
-	    (Tk_ErrorProc *) NULL, (ClientData) NULL);
+    handler = Tk_CreateErrorHandler(Tk_Display(tkwin), -1, -1, -1, NULL, NULL);
     while (1) {
 	if (XTranslateCoordinates(Tk_Display(tkwin), parent, window,
 		x, y, &childX, &childY, &child) == False) {
 	    /*
-	     * We can end up here when the window is in the middle of
-	     * being deleted
+	     * We can end up here when the window is in the middle of being
+	     * deleted
 	     */
+
 	    Tk_DeleteErrorHandler(handler);
 	    return NULL;
 	}
@@ -5161,7 +5119,7 @@ Tk_CoordsToWindow(rootX, rootY, tkwin)
 	    return NULL;
 	}
 	for (wmPtr = (WmInfo *) dispPtr->firstWmPtr; wmPtr != NULL;
-                wmPtr = wmPtr->nextPtr) {
+		wmPtr = wmPtr->nextPtr) {
 	    if (wmPtr->reparent == child) {
 		goto gotToplevel;
 	    }
@@ -5179,12 +5137,13 @@ Tk_CoordsToWindow(rootX, rootY, tkwin)
 	window = child;
     }
 
-    gotToplevel:
+  gotToplevel:
     if (handler) {
 	/*
-	 * Check value of handler, because we can reach this label
-	 * from above or below
+	 * Check value of handler, because we can reach this label from above
+	 * or below
 	 */
+
 	Tk_DeleteErrorHandler(handler);
 	handler = NULL;
     }
@@ -5196,10 +5155,9 @@ Tk_CoordsToWindow(rootX, rootY, tkwin)
     /*
      * Step 3: at this point winPtr and wmPtr refer to the toplevel that
      * contains the given coordinates, and childX and childY give the
-     * translated coordinates in the *parent* of the toplevel.  Now
-     * decide whether the coordinates are in the menubar or the actual
-     * toplevel, and translate the coordinates into the coordinate
-     * system of that window.
+     * translated coordinates in the *parent* of the toplevel. Now decide
+     * whether the coordinates are in the menubar or the actual toplevel, and
+     * translate the coordinates into the coordinate system of that window.
      */
 
     x = childX - winPtr->changes.x;
@@ -5220,17 +5178,18 @@ Tk_CoordsToWindow(rootX, rootY, tkwin)
     }
 
     /*
-     * Step 4: work down through the hierarchy underneath the current
-     * window. At each level, scan through all the children to find the
-     * highest one in the stacking order that contains the point.  Then
-     * repeat the whole process on that child.
+     * Step 4: work down through the hierarchy underneath the current window.
+     * At each level, scan through all the children to find the highest one in
+     * the stacking order that contains the point. Then repeat the whole
+     * process on that child.
      */
 
     while (1) {
 	nextPtr = NULL;
 	for (childPtr = winPtr->childList; childPtr != NULL;
 		childPtr = childPtr->nextPtr) {
-	    if (!Tk_IsMapped(childPtr) || (childPtr->flags & TK_TOP_HIERARCHY)) {
+	    if (!Tk_IsMapped(childPtr)
+		    || (childPtr->flags & TK_TOP_HIERARCHY)) {
 		continue;
 	    }
 	    if (childPtr->flags & TK_REPARENTED) {
@@ -5255,9 +5214,9 @@ Tk_CoordsToWindow(rootX, rootY, tkwin)
 		&& (winPtr->flags & TK_BOTH_HALVES)) {
 	    /*
 	     * The window containing the point is a container, and the
-	     * embedded application is in this same process.  Switch
-	     * over to the toplevel for the embedded application and
-	     * start processing that toplevel from scratch.
+	     * embedded application is in this same process. Switch over to
+	     * the toplevel for the embedded application and start processing
+	     * that toplevel from scratch.
 	     */
 
 	    winPtr = TkpGetOtherWindow(winPtr);
@@ -5275,24 +5234,23 @@ Tk_CoordsToWindow(rootX, rootY, tkwin)
  *
  * UpdateVRootGeometry --
  *
- *	This procedure is called to update all the virtual root
- *	geometry information in wmPtr.
+ *	This function is called to update all the virtual root geometry
+ *	information in wmPtr.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The vRootX, vRootY, vRootWidth, and vRootHeight fields in
- *	wmPtr are filled with the most up-to-date information.
+ *	The vRootX, vRootY, vRootWidth, and vRootHeight fields in wmPtr are
+ *	filled with the most up-to-date information.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-UpdateVRootGeometry(wmPtr)
-    WmInfo *wmPtr;		/* Window manager information to be
-				 * updated.  The wmPtr->vRoot field must
-				 * be valid. */
+UpdateVRootGeometry(
+    WmInfo *wmPtr)		/* Window manager information to be updated.
+				 * The wmPtr->vRoot field must be valid. */
 {
     TkWindow *winPtr = wmPtr->winPtr;
     int bd;
@@ -5308,7 +5266,7 @@ UpdateVRootGeometry(wmPtr)
 
     wmPtr->flags &= ~WM_VROOT_OFFSET_STALE;
     if (wmPtr->vRoot == None) {
-	noVRoot:
+    noVRoot:
 	wmPtr->vRootX = wmPtr->vRootY = 0;
 	wmPtr->vRootWidth = DisplayWidth(winPtr->display, winPtr->screenNum);
 	wmPtr->vRootHeight = DisplayHeight(winPtr->display, winPtr->screenNum);
@@ -5319,8 +5277,7 @@ UpdateVRootGeometry(wmPtr)
      * Refresh the virtual root information if it's out of date.
      */
 
-    handler = Tk_CreateErrorHandler(winPtr->display, -1, -1, -1,
-	    (Tk_ErrorProc *) NULL, (ClientData) NULL);
+    handler = Tk_CreateErrorHandler(winPtr->display, -1, -1, -1, NULL, NULL);
     status = XGetGeometry(winPtr->display, wmPtr->vRoot,
 	    &dummy2, &wmPtr->vRootX, &wmPtr->vRootY,
 	    (unsigned int *) &wmPtr->vRootWidth,
@@ -5334,7 +5291,7 @@ UpdateVRootGeometry(wmPtr)
     Tk_DeleteErrorHandler(handler);
     if (status == 0) {
 	/*
-	 * The virtual root is gone!  Pretend that it never existed.
+	 * The virtual root is gone! Pretend that it never existed.
 	 */
 
 	wmPtr->vRoot = None;
@@ -5347,16 +5304,15 @@ UpdateVRootGeometry(wmPtr)
  *
  * Tk_GetVRootGeometry --
  *
- *	This procedure returns information about the virtual root
- *	window corresponding to a particular Tk window.
+ *	This function returns information about the virtual root window
+ *	corresponding to a particular Tk window.
  *
  * Results:
- *	The values at xPtr, yPtr, widthPtr, and heightPtr are set
- *	with the offset and dimensions of the root window corresponding
- *	to tkwin.  If tkwin is being managed by a virtual root window
- *	manager these values correspond to the virtual root window being
- *	used for tkwin;  otherwise the offsets will be 0 and the
- *	dimensions will be those of the screen.
+ *	The values at xPtr, yPtr, widthPtr, and heightPtr are set with the
+ *	offset and dimensions of the root window corresponding to tkwin. If
+ *	tkwin is being managed by a virtual root window manager these values
+ *	correspond to the virtual root window being used for tkwin; otherwise
+ *	the offsets will be 0 and the dimensions will be those of the screen.
  *
  * Side effects:
  *	Vroot window information is refreshed if it is out of date.
@@ -5365,12 +5321,13 @@ UpdateVRootGeometry(wmPtr)
  */
 
 void
-Tk_GetVRootGeometry(tkwin, xPtr, yPtr, widthPtr, heightPtr)
-    Tk_Window tkwin;		/* Window whose virtual root is to be
+Tk_GetVRootGeometry(
+    Tk_Window tkwin,		/* Window whose virtual root is to be
 				 * queried. */
-    int *xPtr, *yPtr;		/* Store x and y offsets of virtual root
+    int *xPtr, int *yPtr,	/* Store x and y offsets of virtual root
 				 * here. */
-    int *widthPtr, *heightPtr;	/* Store dimensions of virtual root here. */
+    int *widthPtr, int *heightPtr)
+				/* Store dimensions of virtual root here. */
 {
     WmInfo *wmPtr;
     TkWindow *winPtr = (TkWindow *) tkwin;
@@ -5380,7 +5337,8 @@ Tk_GetVRootGeometry(tkwin, xPtr, yPtr, widthPtr, heightPtr)
      * information for that window.
      */
 
-    while (!(winPtr->flags & TK_TOP_HIERARCHY) && (winPtr->parentPtr != NULL)) {
+    while (!(winPtr->flags & TK_TOP_HIERARCHY)
+	    && (winPtr->parentPtr != NULL)) {
 	winPtr = winPtr->parentPtr;
     }
     wmPtr = winPtr->wmInfoPtr;
@@ -5392,10 +5350,9 @@ Tk_GetVRootGeometry(tkwin, xPtr, yPtr, widthPtr, heightPtr)
 	*heightPtr = 0;
     }
 
-
     /*
-     * Make sure that the geometry information is up-to-date, then copy
-     * it out to the caller.
+     * Make sure that the geometry information is up-to-date, then copy it out
+     * to the caller.
      */
 
     if (wmPtr->flags & WM_VROOT_OFFSET_STALE) {
@@ -5412,27 +5369,25 @@ Tk_GetVRootGeometry(tkwin, xPtr, yPtr, widthPtr, heightPtr)
  *
  * Tk_MoveToplevelWindow --
  *
- *	This procedure is called instead of Tk_MoveWindow to adjust
- *	the x-y location of a top-level window.  It delays the actual
- *	move to a later time and keeps window-manager information
- *	up-to-date with the move
+ *	This function is called instead of Tk_MoveWindow to adjust the x-y
+ *	location of a top-level window. It delays the actual move to a later
+ *	time and keeps window-manager information up-to-date with the move
  *
  * Results:
  *	None.
  *
  * Side effects:
  *	The window is eventually moved so that its upper-left corner
- *	(actually, the upper-left corner of the window's decorative
- *	frame, if there is one) is at (x,y).
+ *	(actually, the upper-left corner of the window's decorative frame, if
+ *	there is one) is at (x,y).
  *
  *----------------------------------------------------------------------
  */
 
 void
-Tk_MoveToplevelWindow(tkwin, x, y)
-    Tk_Window tkwin;		/* Window to move. */
-    int x, y;			/* New location for window (within
-				 * parent). */
+Tk_MoveToplevelWindow(
+    Tk_Window tkwin,		/* Window to move. */
+    int x, int y)		/* New location for window (within parent). */
 {
     TkWindow *winPtr = (TkWindow *) tkwin;
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
@@ -5451,9 +5406,8 @@ Tk_MoveToplevelWindow(tkwin, x, y)
 
     /*
      * If the window has already been mapped, must bring its geometry
-     * up-to-date immediately, otherwise an event might arrive from the
-     * server that would overwrite wmPtr->x and wmPtr->y and lose the
-     * new position.
+     * up-to-date immediately, otherwise an event might arrive from the server
+     * that would overwrite wmPtr->x and wmPtr->y and lose the new position.
      */
 
     if (!(wmPtr->flags & WM_NEVER_MAPPED)) {
@@ -5469,9 +5423,9 @@ Tk_MoveToplevelWindow(tkwin, x, y)
  *
  * UpdateWmProtocols --
  *
- *	This procedure transfers the most up-to-date information about
- *	window manager protocols from the WmInfo structure to the actual
- *	property on the top-level window.
+ *	This function transfers the most up-to-date information about window
+ *	manager protocols from the WmInfo structure to the actual property on
+ *	the top-level window.
  *
  * Results:
  *	None.
@@ -5483,8 +5437,8 @@ Tk_MoveToplevelWindow(tkwin, x, y)
  */
 
 static void
-UpdateWmProtocols(wmPtr)
-    register WmInfo *wmPtr;	/* Information about top-level window. */
+UpdateWmProtocols(
+    register WmInfo *wmPtr)	/* Information about top-level window. */
 {
     register ProtocolHandler *protPtr;
     Atom deleteWindowAtom;
@@ -5492,15 +5446,15 @@ UpdateWmProtocols(wmPtr)
     Atom *arrayPtr, *atomPtr;
 
     /*
-     * There are only two tricky parts here.  First, there could be any
-     * number of atoms for the window, so count them and malloc an array
-     * to hold all of their atoms.  Second, we *always* want to respond
-     * to the WM_DELETE_WINDOW protocol, even if no-one's officially asked.
+     * There are only two tricky parts here. First, there could be any number
+     * of atoms for the window, so count them and malloc an array to hold all
+     * of their atoms. Second, we *always* want to respond to the
+     * WM_DELETE_WINDOW protocol, even if no-one's officially asked.
      */
 
     for (protPtr = wmPtr->protPtr, count = 1; protPtr != NULL;
 	    protPtr = protPtr->nextPtr, count++) {
-	/* Empty loop body;  we're just counting the handlers. */
+	/* Empty loop body; we're just counting the handlers. */
     }
     arrayPtr = (Atom *) ckalloc((unsigned) (count * sizeof(Atom)));
     deleteWindowAtom = Tk_InternAtom((Tk_Window) wmPtr->winPtr,
@@ -5525,25 +5479,23 @@ UpdateWmProtocols(wmPtr)
  *
  * TkWmProtocolEventProc --
  *
- *	This procedure is called by the Tk_HandleEvent whenever a
- *	ClientMessage event arrives whose type is "WM_PROTOCOLS".
- *	This procedure handles the message from the window manager
- *	in an appropriate fashion.
+ *	This function is called by the Tk_HandleEvent whenever a ClientMessage
+ *	event arrives whose type is "WM_PROTOCOLS". This function handles the
+ *	message from the window manager in an appropriate fashion.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Depends on what sort of handler, if any, was set up for the
- *	protocol.
+ *	Depends on what sort of handler, if any, was set up for the protocol.
  *
  *----------------------------------------------------------------------
  */
 
 void
-TkWmProtocolEventProc(winPtr, eventPtr)
-    TkWindow *winPtr;		/* Window to which the event was sent. */
-    XEvent *eventPtr;		/* X event. */
+TkWmProtocolEventProc(
+    TkWindow *winPtr,		/* Window to which the event was sent. */
+    XEvent *eventPtr)		/* X event. */
 {
     WmInfo *wmPtr;
     register ProtocolHandler *protPtr;
@@ -5559,11 +5511,11 @@ TkWmProtocolEventProc(winPtr, eventPtr)
     protocol = (Atom) eventPtr->xclient.data.l[0];
 
     /*
-     * Note: it's very important to retrieve the protocol name now,
-     * before invoking the command, even though the name won't be used
-     * until after the command returns.  This is because the command
-     * could delete winPtr, making it impossible for us to use it
-     * later in the call to Tk_GetAtomName.
+     * Note: it's very important to retrieve the protocol name now, before
+     * invoking the command, even though the name won't be used until after
+     * the command returns. This is because the command could delete winPtr,
+     * making it impossible for us to use it later in the call to
+     * Tk_GetAtomName.
      */
 
     protocolName = Tk_GetAtomName((Tk_Window) winPtr, protocol);
@@ -5571,8 +5523,8 @@ TkWmProtocolEventProc(winPtr, eventPtr)
 	    protPtr = protPtr->nextPtr) {
 	if (protocol == protPtr->protocol) {
 	    Tcl_Preserve((ClientData) protPtr);
-            interp = protPtr->interp;
-            Tcl_Preserve((ClientData) interp);
+	    interp = protPtr->interp;
+	    Tcl_Preserve((ClientData) interp);
 	    result = Tcl_GlobalEval(interp, protPtr->command);
 	    if (result != TCL_OK) {
 		Tcl_AddErrorInfo(interp, "\n    (command for \"");
@@ -5581,15 +5533,15 @@ TkWmProtocolEventProc(winPtr, eventPtr)
 			"\" window manager protocol)");
 		Tcl_BackgroundError(interp);
 	    }
-            Tcl_Release((ClientData) interp);
+	    Tcl_Release((ClientData) interp);
 	    Tcl_Release((ClientData) protPtr);
 	    return;
 	}
     }
 
     /*
-     * No handler was present for this protocol.  If this is a
-     * WM_DELETE_WINDOW message then just destroy the window.
+     * No handler was present for this protocol. If this is a WM_DELETE_WINDOW
+     * message then just destroy the window.
      */
 
     if (protocol == Tk_InternAtom((Tk_Window) winPtr, "WM_DELETE_WINDOW")) {
@@ -5602,12 +5554,12 @@ TkWmProtocolEventProc(winPtr, eventPtr)
  *
  * TkWmStackorderToplevelWrapperMap --
  *
- *	This procedure will create a table that maps the reparent wrapper
- *	X id for a toplevel to the TkWindow structure that is wraps.
- *	Tk keeps track of a mapping from the window X id to the TkWindow
- *	structure but that does us no good here since we only get the X
- *	id of the wrapper window. Only those toplevel windows that are
- *	mapped have a position in the stacking order.
+ *	This function will create a table that maps the reparent wrapper X id
+ *	for a toplevel to the TkWindow structure that is wraps. Tk keeps track
+ *	of a mapping from the window X id to the TkWindow structure but that
+ *	does us no good here since we only get the X id of the wrapper window.
+ *	Only those toplevel windows that are mapped have a position in the
+ *	stacking order.
  *
  * Results:
  *	None.
@@ -5619,30 +5571,28 @@ TkWmProtocolEventProc(winPtr, eventPtr)
  */
 
 static void
-TkWmStackorderToplevelWrapperMap(winPtr, display, table)
-    TkWindow *winPtr;				/* TkWindow to recurse on */
-    Display *display;				/* X display of parent window */
-    Tcl_HashTable *table;			/* Maps X id to TkWindow */
+TkWmStackorderToplevelWrapperMap(
+    TkWindow *winPtr,		/* TkWindow to recurse on */
+    Display *display,		/* X display of parent window */
+    Tcl_HashTable *table)	/* Maps X id to TkWindow */
 {
     TkWindow *childPtr;
-    Tcl_HashEntry *hPtr;
-    Window wrapper;
-    int newEntry;
 
     if (Tk_IsMapped(winPtr) && Tk_IsTopLevel(winPtr) &&
-            !Tk_IsEmbedded(winPtr) && (winPtr->display == display)) {
-        wrapper = (winPtr->wmInfoPtr->reparent != None)
-            ? winPtr->wmInfoPtr->reparent
-            : winPtr->wmInfoPtr->wrapperPtr->window;
+	    !Tk_IsEmbedded(winPtr) && (winPtr->display == display)) {
+	Window wrapper = (winPtr->wmInfoPtr->reparent != None)
+		? winPtr->wmInfoPtr->reparent
+		: winPtr->wmInfoPtr->wrapperPtr->window;
+	Tcl_HashEntry *hPtr;
+	int newEntry;
 
-        hPtr = Tcl_CreateHashEntry(table,
-            (char *) wrapper, &newEntry);
-        Tcl_SetHashValue(hPtr, winPtr);
+	hPtr = Tcl_CreateHashEntry(table, (char *) wrapper, &newEntry);
+	Tcl_SetHashValue(hPtr, winPtr);
     }
 
     for (childPtr = winPtr->childList; childPtr != NULL;
-            childPtr = childPtr->nextPtr) {
-        TkWmStackorderToplevelWrapperMap(childPtr, display, table);
+	    childPtr = childPtr->nextPtr) {
+	TkWmStackorderToplevelWrapperMap(childPtr, display, table);
     }
 }
 
@@ -5651,11 +5601,11 @@ TkWmStackorderToplevelWrapperMap(winPtr, display, table)
  *
  * TkWmStackorderToplevel --
  *
- *	This procedure returns the stack order of toplevel windows.
+ *	This function returns the stack order of toplevel windows.
  *
  * Results:
- *	An array of pointers to tk window objects in stacking order
- *	or else NULL if there was an error.
+ *	An array of pointers to tk window objects in stacking order or else
+ *	NULL if there was an error.
  *
  * Side effects:
  *	None.
@@ -5664,8 +5614,8 @@ TkWmStackorderToplevelWrapperMap(winPtr, display, table)
  */
 
 TkWindow **
-TkWmStackorderToplevel(parentPtr)
-    TkWindow *parentPtr;		/* Parent toplevel window. */
+TkWmStackorderToplevel(
+    TkWindow *parentPtr)	/* Parent toplevel window. */
 {
     Window dummy1, dummy2, vRoot;
     Window *children;
@@ -5682,51 +5632,52 @@ TkWmStackorderToplevel(parentPtr)
     Tcl_InitHashTable(&table, TCL_ONE_WORD_KEYS);
     TkWmStackorderToplevelWrapperMap(parentPtr, parentPtr->display, &table);
 
-    window_ptr = windows = (TkWindow **) ckalloc((table.numEntries+1)
-        * sizeof(TkWindow *));
+    window_ptr = windows = (TkWindow **)
+	    ckalloc((table.numEntries+1) * sizeof(TkWindow *));
 
     /*
-     * Special cases: If zero or one toplevels were mapped
-     * there is no need to call XQueryTree.
+     * Special cases: If zero or one toplevels were mapped there is no need to
+     * call XQueryTree.
      */
 
     switch (table.numEntries) {
     case 0:
-        windows[0] = NULL;
-        goto done;
+	windows[0] = NULL;
+	goto done;
     case 1:
-        hPtr = Tcl_FirstHashEntry(&table, &search);
-        windows[0] = (TkWindow *) Tcl_GetHashValue(hPtr);
-        windows[1] = NULL;
-        goto done;
+	hPtr = Tcl_FirstHashEntry(&table, &search);
+	windows[0] = (TkWindow *) Tcl_GetHashValue(hPtr);
+	windows[1] = NULL;
+	goto done;
     }
 
     vRoot = parentPtr->wmInfoPtr->vRoot;
     if (vRoot == None) {
-        vRoot = RootWindowOfScreen(Tk_Screen((Tk_Window) parentPtr));
+	vRoot = RootWindowOfScreen(Tk_Screen((Tk_Window) parentPtr));
     }
 
     if (XQueryTree(parentPtr->display, vRoot, &dummy1, &dummy2,
-            &children, &numChildren) == 0) {
-        ckfree((char *) windows);
-        windows = NULL;
+	    &children, &numChildren) == 0) {
+	ckfree((char *) windows);
+	windows = NULL;
     } else {
-        for (i = 0; i < numChildren; i++) {
-            hPtr = Tcl_FindHashEntry(&table, (char *) children[i]);
-            if (hPtr != NULL) {
-                childWinPtr = (TkWindow *) Tcl_GetHashValue(hPtr);
-                *window_ptr++ = childWinPtr;
-            }
-        }
-        if ((window_ptr - windows) != table.numEntries)
-            Tcl_Panic("num matched toplevel windows does not equal num children");
-        *window_ptr = NULL;
+	for (i = 0; i < numChildren; i++) {
+	    hPtr = Tcl_FindHashEntry(&table, (char *) children[i]);
+	    if (hPtr != NULL) {
+		childWinPtr = (TkWindow *) Tcl_GetHashValue(hPtr);
+		*window_ptr++ = childWinPtr;
+	    }
+	}
+	if ((window_ptr - windows) != table.numEntries) {
+	    Tcl_Panic("num matched toplevel windows does not equal num children");
+	}
+	*window_ptr = NULL;
 	if (numChildren) {
 	    XFree((char *) children);
 	}
     }
 
-    done:
+  done:
     Tcl_DeleteHashTable(&table);
     return windows;
 }
@@ -5736,25 +5687,25 @@ TkWmStackorderToplevel(parentPtr)
  *
  * TkWmRestackToplevel --
  *
- *	This procedure restacks a top-level window.
+ *	This function restacks a top-level window.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	WinPtr gets restacked  as specified by aboveBelow and otherPtr.
+ *	WinPtr gets restacked as specified by aboveBelow and otherPtr.
  *
  *----------------------------------------------------------------------
  */
 
 void
-TkWmRestackToplevel(winPtr, aboveBelow, otherPtr)
-    TkWindow *winPtr;		/* Window to restack. */
-    int aboveBelow;		/* Gives relative position for restacking;
+TkWmRestackToplevel(
+    TkWindow *winPtr,		/* Window to restack. */
+    int aboveBelow,		/* Gives relative position for restacking;
 				 * must be Above or Below. */
-    TkWindow *otherPtr;		/* Window relative to which to restack;
-				 * if NULL, then winPtr gets restacked
-				 * above or below *all* siblings. */
+    TkWindow *otherPtr)		/* Window relative to which to restack; if
+				 * NULL, then winPtr gets restacked above or
+				 * below *all* siblings. */
 {
     XWindowChanges changes;
     unsigned int mask;
@@ -5767,6 +5718,7 @@ TkWmRestackToplevel(winPtr, aboveBelow, otherPtr)
     /*
      * Make sure that winPtr and its wrapper window have been created.
      */
+
     if (winPtr->wmInfoPtr->flags & WM_NEVER_MAPPED) {
 	TkWmMapWindow(winPtr);
     }
@@ -5777,6 +5729,7 @@ TkWmRestackToplevel(winPtr, aboveBelow, otherPtr)
 	 * The window is to be restacked with respect to another toplevel.
 	 * Make sure it has been created as well.
 	 */
+
 	if (otherPtr->wmInfoPtr->flags & WM_NEVER_MAPPED) {
 	    TkWmMapWindow(otherPtr);
 	}
@@ -5785,15 +5738,14 @@ TkWmRestackToplevel(winPtr, aboveBelow, otherPtr)
     }
 
     /*
-     * Reconfigure the window.  Note that we use XReconfigureWMWindow
-     * instead of XConfigureWindow, in order to handle the case
-     * where the window is to be restacked with respect to another toplevel.  
-     * See [ICCCM] 4.1.5 "Configuring the Window" and XReconfigureWMWindow(3)
-     * for details.
+     * Reconfigure the window. Note that we use XReconfigureWMWindow instead
+     * of XConfigureWindow, in order to handle the case where the window is to
+     * be restacked with respect to another toplevel. See [ICCCM] 4.1.5
+     * "Configuring the Window" and XReconfigureWMWindow(3) for details.
      */
 
     XReconfigureWMWindow(winPtr->display, wrapperPtr->window,
-	    Tk_ScreenNumber((Tk_Window) winPtr), mask,  &changes);
+	    Tk_ScreenNumber((Tk_Window) winPtr), mask, &changes);
 }
 
 
@@ -5802,28 +5754,27 @@ TkWmRestackToplevel(winPtr, aboveBelow, otherPtr)
  *
  * TkWmAddToColormapWindows --
  *
- *	This procedure is called to add a given window to the
- *	WM_COLORMAP_WINDOWS property for its top-level, if it
- *	isn't already there.  It is invoked by the Tk code that
- *	creates a new colormap, in order to make sure that colormap
- *	information is propagated to the window manager by default.
+ *	This function is called to add a given window to the
+ *	WM_COLORMAP_WINDOWS property for its top-level, if it isn't already
+ *	there. It is invoked by the Tk code that creates a new colormap, in
+ *	order to make sure that colormap information is propagated to the
+ *	window manager by default.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	WinPtr's window gets added to the WM_COLORMAP_WINDOWS
- *	property of its nearest top-level ancestor, unless the
- *	colormaps have been set explicitly with the
- *	"wm colormapwindows" command.
+ *	WinPtr's window gets added to the WM_COLORMAP_WINDOWS property of its
+ *	nearest top-level ancestor, unless the colormaps have been set
+ *	explicitly with the "wm colormapwindows" command.
  *
  *----------------------------------------------------------------------
  */
 
 void
-TkWmAddToColormapWindows(winPtr)
-    TkWindow *winPtr;		/* Window with a non-default colormap.
-				 * Should not be a top-level window. */
+TkWmAddToColormapWindows(
+    TkWindow *winPtr)		/* Window with a non-default colormap. Should
+				 * not be a top-level window. */
 {
     TkWindow *wrapperPtr;
     TkWindow *topPtr;
@@ -5837,7 +5788,7 @@ TkWmAddToColormapWindows(winPtr)
     for (topPtr = winPtr->parentPtr; ; topPtr = topPtr->parentPtr) {
 	if (topPtr == NULL) {
 	    /*
-	     * Window is being deleted.  Skip the whole operation.
+	     * Window is being deleted. Skip the whole operation.
 	     */
 
 	    return;
@@ -5879,9 +5830,8 @@ TkWmAddToColormapWindows(winPtr)
     }
 
     /*
-     * Make a new bigger array and use it to reset the property.
-     * Automatically add the toplevel itself as the last element
-     * of the list.
+     * Make a new bigger array and use it to reset the property. Automatically
+     * add the toplevel itself as the last element of the list.
      */
 
     newPtr = (Window *) ckalloc((unsigned) ((count+2)*sizeof(Window)));
@@ -5906,26 +5856,26 @@ TkWmAddToColormapWindows(winPtr)
  *
  * TkWmRemoveFromColormapWindows --
  *
- *	This procedure is called to remove a given window from the
- *	WM_COLORMAP_WINDOWS property for its top-level.  It is invoked
- *	when windows are deleted.
+ *	This function is called to remove a given window from the
+ *	WM_COLORMAP_WINDOWS property for its top-level. It is invoked when
+ *	windows are deleted.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	WinPtr's window gets removed from the WM_COLORMAP_WINDOWS
- *	property of its nearest top-level ancestor, unless the
- *	top-level itself is being deleted too.
+ *	WinPtr's window gets removed from the WM_COLORMAP_WINDOWS property of
+ *	its nearest top-level ancestor, unless the top-level itself is being
+ *	deleted too.
  *
  *----------------------------------------------------------------------
  */
 
 void
-TkWmRemoveFromColormapWindows(winPtr)
-    TkWindow *winPtr;		/* Window that may be present in
+TkWmRemoveFromColormapWindows(
+    TkWindow *winPtr)		/* Window that may be present in
 				 * WM_COLORMAP_WINDOWS property for its
-				 * top-level.  Should not be a top-level
+				 * top-level. Should not be a top-level
 				 * window. */
 {
     TkWindow *wrapperPtr;
@@ -5952,8 +5902,8 @@ TkWmRemoveFromColormapWindows(winPtr)
     }
     if (topPtr->flags & TK_ALREADY_DEAD) {
 	/*
-	 * Top-level is being deleted, so there's no need to cleanup
-	 * the WM_COLORMAP_WINDOWS property.
+	 * Top-level is being deleted, so there's no need to cleanup the
+	 * WM_COLORMAP_WINDOWS property.
 	 */
 
 	return;
@@ -5980,8 +5930,7 @@ TkWmRemoveFromColormapWindows(winPtr)
     }
 
     /*
-     * Find the window and slide the following ones down to cover
-     * it up.
+     * Find the window and slide the following ones down to cover it up.
      */
 
     for (i = 0; i < count; i++) {
@@ -6005,10 +5954,10 @@ TkWmRemoveFromColormapWindows(winPtr)
  *	Fetch the position of the mouse pointer.
  *
  * Results:
- *	*xPtr and *yPtr are filled in with the (virtual) root coordinates
- *	of the mouse pointer for tkwin's display.  If the pointer isn't
- *	on tkwin's screen, then -1 values are returned for both
- *	coordinates.  The argument tkwin must be a toplevel window.
+ *	*xPtr and *yPtr are filled in with the (virtual) root coordinates of
+ *	the mouse pointer for tkwin's display. If the pointer isn't on tkwin's
+ *	screen, then -1 values are returned for both coordinates. The argument
+ *	tkwin must be a toplevel window.
  *
  * Side effects:
  *	None.
@@ -6017,10 +5966,10 @@ TkWmRemoveFromColormapWindows(winPtr)
  */
 
 void
-TkGetPointerCoords(tkwin, xPtr, yPtr)
-    Tk_Window tkwin;		/* Toplevel window that identifies screen
-				 * on which lookup is to be done. */
-    int *xPtr, *yPtr;		/* Store pointer coordinates here. */
+TkGetPointerCoords(
+    Tk_Window tkwin,		/* Toplevel window that identifies screen on
+				 * which lookup is to be done. */
+    int *xPtr, int *yPtr)	/* Store pointer coordinates here. */
 {
     TkWindow *winPtr = (TkWindow *) tkwin;
     WmInfo *wmPtr;
@@ -6046,16 +5995,15 @@ TkGetPointerCoords(tkwin, xPtr, yPtr)
  *
  * GetMaxSize --
  *
- *	This procedure computes the current maxWidth and maxHeight
- *	values for a window, taking into account the possibility
- *	that they may be defaulted.
+ *	This function computes the current maxWidth and maxHeight values for a
+ *	window, taking into account the possibility that they may be
+ *	defaulted.
  *
  * Results:
- *	The values at *maxWidthPtr and *maxHeightPtr are filled
- *	in with the maximum allowable dimensions of wmPtr's window,
- *	in grid units.  If no maximum has been specified for the
- *	window, then this procedure computes the largest sizes that
- *	will fit on the screen.
+ *	The values at *maxWidthPtr and *maxHeightPtr are filled in with the
+ *	maximum allowable dimensions of wmPtr's window, in grid units. If no
+ *	maximum has been specified for the window, then this function computes
+ *	the largest sizes that will fit on the screen.
  *
  * Side effects:
  *	None.
@@ -6064,13 +6012,13 @@ TkGetPointerCoords(tkwin, xPtr, yPtr)
  */
 
 static void
-GetMaxSize(wmPtr, maxWidthPtr, maxHeightPtr)
-    WmInfo *wmPtr;		/* Window manager information for the
+GetMaxSize(
+    WmInfo *wmPtr,		/* Window manager information for the
 				 * window. */
-    int *maxWidthPtr;		/* Where to store the current maximum
-				 * width of the window. */
-    int *maxHeightPtr;		/* Where to store the current maximum
-				 * height of the window. */
+    int *maxWidthPtr,		/* Where to store the current maximum width of
+				 * the window. */
+    int *maxHeightPtr)		/* Where to store the current maximum height
+				 * of the window. */
 {
     int tmp;
 
@@ -6078,15 +6026,15 @@ GetMaxSize(wmPtr, maxWidthPtr, maxHeightPtr)
 	*maxWidthPtr = wmPtr->maxWidth;
     } else {
 	/*
-	 * Must compute a default width.  Fill up the display, leaving a
-	 * bit of extra space for the window manager's borders.
+	 * Must compute a default width. Fill up the display, leaving a bit of
+	 * extra space for the window manager's borders.
 	 */
 
 	tmp = DisplayWidth(wmPtr->winPtr->display, wmPtr->winPtr->screenNum)
 	    - 15;
 	if (wmPtr->gridWin != NULL) {
 	    /*
-	     * Gridding is turned on;  convert from pixels to grid units.
+	     * Gridding is turned on; convert from pixels to grid units.
 	     */
 
 	    tmp = wmPtr->reqGridWidth
@@ -6112,8 +6060,8 @@ GetMaxSize(wmPtr, maxWidthPtr, maxHeightPtr)
  *
  * TkpMakeMenuWindow --
  *
- *	Configure the window to be either a pull-down (or pop-up)
- *	menu, or as a toplevel (torn-off) menu or palette.
+ *	Configure the window to be either a pull-down (or pop-up) menu, or as
+ *	a toplevel (torn-off) menu or palette.
  *
  * Results:
  *	None.
@@ -6125,12 +6073,12 @@ GetMaxSize(wmPtr, maxWidthPtr, maxHeightPtr)
  */
 
 void
-TkpMakeMenuWindow(tkwin, transient)
-    Tk_Window tkwin;		/* New window. */
-    int transient;		/* 1 means menu is only posted briefly as
-				 * a popup or pulldown or cascade.  0 means
-				 * menu is always visible, e.g. as a torn-off
-				 * menu.  Determines whether save_under and
+TkpMakeMenuWindow(
+    Tk_Window tkwin,		/* New window. */
+    int transient)		/* 1 means menu is only posted briefly as a
+				 * popup or pulldown or cascade. 0 means menu
+				 * is always visible, e.g. as a torn-off menu.
+				 * Determines whether save_under and
 				 * override_redirect should be set. */
 {
     WmInfo *wmPtr;
@@ -6154,13 +6102,13 @@ TkpMakeMenuWindow(tkwin, transient)
     }
 
     /*
-     * The override-redirect and save-under bits must be set on the
-     * wrapper window in order to have the desired effect.  However,
-     * also set the override-redirect bit on the window itself, so
-     * that the "wm overrideredirect" command will see it.
+     * The override-redirect and save-under bits must be set on the wrapper
+     * window in order to have the desired effect. However, also set the
+     * override-redirect bit on the window itself, so that the "wm
+     * overrideredirect" command will see it.
      */
 
-    if ((atts.override_redirect != Tk_Attributes(wrapperPtr)->override_redirect)
+    if ((atts.override_redirect!=Tk_Attributes(wrapperPtr)->override_redirect)
 	    || (atts.save_under != Tk_Attributes(wrapperPtr)->save_under)) {
 	Tk_ChangeWindowAttributes((Tk_Window) wrapperPtr,
 		CWOverrideRedirect|CWSaveUnder, &atts);
@@ -6175,9 +6123,9 @@ TkpMakeMenuWindow(tkwin, transient)
  *
  * CreateWrapper --
  *
- *	This procedure is invoked to create the wrapper window for a
- *	toplevel window.  It is called just before a toplevel is mapped
- *	for the first time.
+ *	This function is invoked to create the wrapper window for a toplevel
+ *	window. It is called just before a toplevel is mapped for the first
+ *	time.
  *
  * Results:
  *	None.
@@ -6189,8 +6137,8 @@ TkpMakeMenuWindow(tkwin, transient)
  */
 
 static void
-CreateWrapper(wmPtr)
-    WmInfo *wmPtr;		/* Window manager information for the
+CreateWrapper(
+    WmInfo *wmPtr)		/* Window manager information for the
 				 * window. */
 {
     TkWindow *winPtr, *wrapperPtr;
@@ -6204,12 +6152,12 @@ CreateWrapper(wmPtr)
     }
 
     /*
-     * The code below is copied from CreateTopLevelWindow,
-     * Tk_MakeWindowExist, and TkpMakeWindow; The idea is to create an
-     * "official" Tk window (so that we can get events on it), but to
-     * hide the window outside the official Tk hierarchy so that it
-     * isn't visible to the application.  See the comments for the other
-     * procedures if you have questions about this code.
+     * The code below is copied from CreateTopLevelWindow, Tk_MakeWindowExist,
+     * and TkpMakeWindow. The idea is to create an "official" Tk window (so
+     * that we can get events on it), but to hide the window outside the
+     * official Tk hierarchy so that it isn't visible to the application. See
+     * the comments for the other functions if you have questions about this
+     * code.
      */
 
     wmPtr->wrapperPtr = wrapperPtr = TkAllocWindow(winPtr->dispPtr,
@@ -6217,12 +6165,11 @@ CreateWrapper(wmPtr)
     wrapperPtr->dirtyAtts |= CWBorderPixel;
 
     /*
-     * Tk doesn't normally select for StructureNotifyMask events because
-     * the events are synthesized internally.  However, for wrapper
-     * windows we need to know when the window manager modifies the
-     * window configuration.  We also need to select on focus change
-     * events; these are the only windows for which we care about focus
-     * changes.
+     * Tk doesn't normally select for StructureNotifyMask events because the
+     * events are synthesized internally. However, for wrapper windows we need
+     * to know when the window manager modifies the window configuration. We
+     * also need to select on focus change events; these are the only windows
+     * for which we care about focus changes.
      */
 
     wrapperPtr->flags |= TK_WRAPPER;
@@ -6257,9 +6204,9 @@ CreateWrapper(wmPtr)
 	    0, 0);
 
     /*
-     * Tk must monitor structure events for wrapper windows in order
-     * to detect changes made by window managers such as resizing,
-     * mapping, unmapping, etc..
+     * Tk must monitor structure events for wrapper windows in order to detect
+     * changes made by window managers such as resizing, mapping, unmapping,
+     * etc..
      */
 
     Tk_CreateEventHandler((Tk_Window) wmPtr->wrapperPtr, StructureNotifyMask,
@@ -6271,16 +6218,15 @@ CreateWrapper(wmPtr)
  *
  * TkWmFocusToplevel --
  *
- *	This is a utility procedure invoked by focus-management code.
- *	The focus code responds to externally generated focus-related
- *	events on wrapper windows but ignores those events for any other
- *	windows.  This procedure determines whether a given window is a
- *	wrapper window and, if so, returns the toplevel window
- *	corresponding to the wrapper.
+ *	This is a utility function invoked by focus-management code. The focus
+ *	code responds to externally generated focus-related events on wrapper
+ *	windows but ignores those events for any other windows. This function
+ *	determines whether a given window is a wrapper window and, if so,
+ *	returns the toplevel window corresponding to the wrapper.
  *
  * Results:
- *	If winPtr is a wrapper window, returns a pointer to the
- *	corresponding toplevel window; otherwise returns NULL.
+ *	If winPtr is a wrapper window, returns a pointer to the corresponding
+ *	toplevel window; otherwise returns NULL.
  *
  * Side effects:
  *	None.
@@ -6289,8 +6235,8 @@ CreateWrapper(wmPtr)
  */
 
 TkWindow *
-TkWmFocusToplevel(winPtr)
-    TkWindow *winPtr;		/* Window that received a focus-related
+TkWmFocusToplevel(
+    TkWindow *winPtr)		/* Window that received a focus-related
 				 * event. */
 {
     if (!(winPtr->flags & TK_WRAPPER)) {
@@ -6304,31 +6250,30 @@ TkWmFocusToplevel(winPtr)
  *
  * TkUnixSetMenubar --
  *
- *	This procedure is invoked by menu management code to specify the
- *	window to use as a menubar for a given toplevel window.
+ *	This function is invoked by menu management code to specify the window
+ *	to use as a menubar for a given toplevel window.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The window given by menubar will be mapped and positioned inside
- *	the wrapper for tkwin and above tkwin.  Menubar will
- *	automatically be resized to maintain the height specified by
- *	TkUnixSetMenuHeight the same width as tkwin.  Any previous
- *	menubar specified for tkwin will be unmapped and ignored from
- *	now on.
+ *	The window given by menubar will be mapped and positioned inside the
+ *	wrapper for tkwin and above tkwin. Menubar will automatically be
+ *	resized to maintain the height specified by TkUnixSetMenuHeight the
+ *	same width as tkwin. Any previous menubar specified for tkwin will be
+ *	unmapped and ignored from now on.
  *
  *----------------------------------------------------------------------
  */
 
 void
-TkUnixSetMenubar(tkwin, menubar)
-    Tk_Window tkwin;		/* Token for toplevel window. */
-    Tk_Window menubar;		/* Token for window that is to serve as
-				 * menubar for tkwin.  Must not be a
-				 * toplevel window.  If NULL, any
-				 * existing menubar is canceled and the
-				 * menu height is reset to 0. */
+TkUnixSetMenubar(
+    Tk_Window tkwin,		/* Token for toplevel window. */
+    Tk_Window menubar)		/* Token for window that is to serve as
+				 * menubar for tkwin. Must not be a toplevel
+				 * window. If NULL, any existing menubar is
+				 * canceled and the menu height is reset to
+				 * 0. */
 {
     WmInfo *wmPtr = ((TkWindow *) tkwin)->wmInfoPtr;
     Tk_Window parent;
@@ -6336,9 +6281,9 @@ TkUnixSetMenubar(tkwin, menubar)
 
     if (wmPtr->menubar != NULL) {
 	/*
-	 * There's already a menubar for this toplevel.  If it isn't the
-	 * same as the new menubar, unmap it so that it is out of the
-	 * way, and reparent it back to its original parent.
+	 * There's already a menubar for this toplevel. If it isn't the same
+	 * as the new menubar, unmap it so that it is out of the way, and
+	 * reparent it back to its original parent.
 	 */
 
 	if (wmPtr->menubar == menubar) {
@@ -6355,7 +6300,7 @@ TkUnixSetMenubar(tkwin, menubar)
 	}
 	Tk_DeleteEventHandler(wmPtr->menubar, StructureNotifyMask,
 		MenubarDestroyProc, (ClientData) wmPtr->menubar);
-	Tk_ManageGeometry(wmPtr->menubar, NULL, (ClientData) NULL);
+	Tk_ManageGeometry(wmPtr->menubar, NULL, NULL);
     }
 
     wmPtr->menubar = menubar;
@@ -6363,7 +6308,7 @@ TkUnixSetMenubar(tkwin, menubar)
 	wmPtr->menuHeight = 0;
     } else {
 	if ((menubarPtr->flags & TK_TOP_LEVEL)
-	     || (Tk_Screen(menubar) != Tk_Screen(tkwin))) {
+		|| (Tk_Screen(menubar) != Tk_Screen(tkwin))) {
 	    Tcl_Panic("TkUnixSetMenubar got bad menubar");
 	}
 	wmPtr->menuHeight = Tk_ReqHeight(menubar);
@@ -6397,24 +6342,24 @@ TkUnixSetMenubar(tkwin, menubar)
  *
  * MenubarDestroyProc --
  *
- *	This procedure is invoked by the event dispatcher whenever a
- *	menubar window is destroyed (it's also invoked for a few other
- *	kinds of events, but we ignore those).
+ *	This function is invoked by the event dispatcher whenever a menubar
+ *	window is destroyed (it's also invoked for a few other kinds of
+ *	events, but we ignore those).
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The association between the window and its toplevel is broken,
- *	so that the window is no longer considered to be a menubar.
+ *	The association between the window and its toplevel is broken, so that
+ *	the window is no longer considered to be a menubar.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-MenubarDestroyProc(clientData, eventPtr)
-    ClientData clientData;		/* TkWindow pointer for menubar. */
-    XEvent *eventPtr;			/* Describes what just happened. */
+MenubarDestroyProc(
+    ClientData clientData,	/* TkWindow pointer for menubar. */
+    XEvent *eventPtr)		/* Describes what just happened. */
 {
     WmInfo *wmPtr;
 
@@ -6436,9 +6381,8 @@ MenubarDestroyProc(clientData, eventPtr)
  *
  * MenubarReqProc --
  *
- *	This procedure is invoked by the Tk geometry management code
- *	whenever a menubar calls Tk_GeometryRequest to request a new
- *	size.
+ *	This function is invoked by the Tk geometry management code whenever a
+ *	menubar calls Tk_GeometryRequest to request a new size.
  *
  * Results:
  *	None.
@@ -6450,10 +6394,10 @@ MenubarDestroyProc(clientData, eventPtr)
  */
 
 static void
-MenubarReqProc(clientData, tkwin)
-    ClientData clientData;	/* Pointer to the window manager
-				 * information for tkwin's toplevel. */
-    Tk_Window tkwin;		/* Handle for menubar window. */
+MenubarReqProc(
+    ClientData clientData,	/* Pointer to the window manager information
+				 * for tkwin's toplevel. */
+    Tk_Window tkwin)		/* Handle for menubar window. */
 {
     WmInfo *wmPtr = (WmInfo *) clientData;
 
@@ -6473,12 +6417,12 @@ MenubarReqProc(clientData, tkwin)
  *
  * TkpGetWrapperWindow --
  *
- *	Given a toplevel window return the hidden wrapper window for
- *	the toplevel window if available.
+ *	Given a toplevel window return the hidden wrapper window for the
+ *	toplevel window if available.
  *
  * Results:
- *	The wrapper window.  NULL is we were not passed a toplevel
- *	window or the wrapper has yet to be created.
+ *	The wrapper window. NULL is we were not passed a toplevel window or
+ *	the wrapper has yet to be created.
  *
  * Side effects:
  *	None.
@@ -6487,8 +6431,8 @@ MenubarReqProc(clientData, tkwin)
  */
 
 TkWindow *
-TkpGetWrapperWindow(winPtr)
-    TkWindow *winPtr;		/* A toplevel window pointer. */
+TkpGetWrapperWindow(
+    TkWindow *winPtr)		/* A toplevel window pointer. */
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
 
@@ -6504,8 +6448,8 @@ TkpGetWrapperWindow(winPtr)
  *
  * UpdateCommand --
  *
- *	Update the WM_COMMAND property, taking care to translate
- *	the command strings into the external encoding.
+ *	Update the WM_COMMAND property, taking care to translate the command
+ *	strings into the external encoding.
  *
  * Results:
  *	None.
@@ -6517,8 +6461,8 @@ TkpGetWrapperWindow(winPtr)
  */
 
 static void
-UpdateCommand(winPtr)
-    TkWindow  *winPtr;
+UpdateCommand(
+    TkWindow *winPtr)
 {
     register WmInfo *wmPtr = winPtr->wmInfoPtr;
     Tcl_DString cmds, ds;
@@ -6526,15 +6470,15 @@ UpdateCommand(winPtr)
     char **cmdArgv;
 
     /*
-     * Translate the argv strings into the external encoding.  To avoid
-     * allocating lots of memory, the strings are appended to a buffer
-     * with nulls between each string.
+     * Translate the argv strings into the external encoding. To avoid
+     * allocating lots of memory, the strings are appended to a buffer with
+     * nulls between each string.
      *
-     * This code is tricky because we need to pass and array of pointers
-     * to XSetCommand.  However, we can't compute the pointers as we go
-     * because the DString buffer space could get reallocated.  So, store
-     * offsets for each element as we go, then compute pointers from the
-     * offsets once the entire DString is done.
+     * This code is tricky because we need to pass and array of pointers to
+     * XSetCommand. However, we can't compute the pointers as we go because
+     * the DString buffer space could get reallocated. So, store offsets for
+     * each element as we go, then compute pointers from the offsets once the
+     * entire DString is done.
      */
 
     cmdArgv = (char **) ckalloc(sizeof(char *) * wmPtr->cmdArgc);
@@ -6564,8 +6508,8 @@ UpdateCommand(winPtr)
  *
  * TkpWmSetState --
  *
- *	Sets the window manager state for the wrapper window of a
- *	given toplevel window.
+ *	Sets the window manager state for the wrapper window of a given
+ *	toplevel window.
  *
  * Results:
  *	0 on error, 1 otherwise
@@ -6577,49 +6521,57 @@ UpdateCommand(winPtr)
  */
 
 int
-TkpWmSetState(winPtr, state)
-     TkWindow *winPtr;		/* Toplevel window to operate on. */
-     int state;			/* One of IconicState, NormalState,
-				 * or WithdrawnState. */
+TkpWmSetState(
+     TkWindow *winPtr,		/* Toplevel window to operate on. */
+     int state)			/* One of IconicState, NormalState, or
+				 * WithdrawnState. */
 {
     WmInfo *wmPtr = winPtr->wmInfoPtr;
 
     if (state == WithdrawnState) {
-        wmPtr->hints.initial_state = WithdrawnState;
-        wmPtr->withdrawn = 1;
-        if (wmPtr->flags & WM_NEVER_MAPPED) {
-            return 1;
-        }
-        if (XWithdrawWindow(winPtr->display, wmPtr->wrapperPtr->window,
-                winPtr->screenNum) == 0) {
-            return 0;
-        }
-        WaitForMapNotify(winPtr, 0);
+	wmPtr->hints.initial_state = WithdrawnState;
+	wmPtr->withdrawn = 1;
+	if (wmPtr->flags & WM_NEVER_MAPPED) {
+	    return 1;
+	}
+	if (XWithdrawWindow(winPtr->display, wmPtr->wrapperPtr->window,
+		winPtr->screenNum) == 0) {
+	    return 0;
+	}
+	WaitForMapNotify(winPtr, 0);
     } else if (state == NormalState) {
-        wmPtr->hints.initial_state = NormalState;
-        wmPtr->withdrawn = 0;
-        if (wmPtr->flags & WM_NEVER_MAPPED) {
-            return 1;
-        }
-        UpdateHints(winPtr);
-        Tk_MapWindow((Tk_Window) winPtr);
+	wmPtr->hints.initial_state = NormalState;
+	wmPtr->withdrawn = 0;
+	if (wmPtr->flags & WM_NEVER_MAPPED) {
+	    return 1;
+	}
+	UpdateHints(winPtr);
+	Tk_MapWindow((Tk_Window) winPtr);
     } else if (state == IconicState) {
-        wmPtr->hints.initial_state = IconicState;
-        if (wmPtr->flags & WM_NEVER_MAPPED) {
-            return 1;
-        }
-        if (wmPtr->withdrawn) {
-            UpdateHints(winPtr);
-            Tk_MapWindow((Tk_Window) winPtr);
-            wmPtr->withdrawn = 0;
-        } else {
-            if (XIconifyWindow(winPtr->display, wmPtr->wrapperPtr->window,
-                    winPtr->screenNum) == 0) {
-                return 0;
-            }
-            WaitForMapNotify(winPtr, 0);
-        }
+	wmPtr->hints.initial_state = IconicState;
+	if (wmPtr->flags & WM_NEVER_MAPPED) {
+	    return 1;
+	}
+	if (wmPtr->withdrawn) {
+	    UpdateHints(winPtr);
+	    Tk_MapWindow((Tk_Window) winPtr);
+	    wmPtr->withdrawn = 0;
+	} else {
+	    if (XIconifyWindow(winPtr->display, wmPtr->wrapperPtr->window,
+		    winPtr->screenNum) == 0) {
+		return 0;
+	    }
+	    WaitForMapNotify(winPtr, 0);
+	}
     }
 
     return 1;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tkUnixXId.c b/unix/tkUnixXId.c
index 9f3dd82..37a621f 100644
--- a/unix/tkUnixXId.c
+++ b/unix/tkUnixXId.c
@@ -1,12 +1,11 @@
-/* 
+/*
  * tkUnixXId.c --
  *
- *	This file provides a replacement function for the default X
- *	resource allocator (_XAllocID).  The problem with the default
- *	allocator is that it never re-uses ids, which causes long-lived
- *	applications to crash when X resource identifiers wrap around.
- *	The replacement functions in this file re-use old identifiers
- *	to prevent this problem.
+ *	This file provides a replacement function for the default X resource
+ *	allocator (_XAllocID). The problem with the default allocator is that
+ *	it never re-uses ids, which causes long-lived applications to crash
+ *	when X resource identifiers wrap around. The replacement functions in
+ *	this file re-use old identifiers to prevent this problem.
  *
  *	The code in this file is based on similar implementations by
  *	George C. Kaplan and Michael Hoegeman.
@@ -14,16 +13,16 @@
  * Copyright (c) 1993 The Regents of the University of California.
  * Copyright (c) 1994-1997 Sun Microsystems, Inc.
  *
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkUnixXId.c,v 1.7 2002/04/12 10:06:09 hobbs Exp $
+ * RCS: @(#) $Id: tkUnixXId.c,v 1.8 2005/10/21 01:51:45 dkf Exp $
  */
 
 /*
- * The definition below is needed on some systems so that we can access
- * the resource_alloc field of Display structures in order to replace
- * the resource allocator.
+ * The definition below is needed on some systems so that we can access the
+ * resource_alloc field of Display structures in order to replace the resource
+ * allocator.
  */
 
 #define XLIB_ILLEGAL_ACCESS 1
@@ -32,38 +31,37 @@
 #include "tkPort.h"
 
 /*
- * A structure of the following type is used to hold one or more
- * available resource identifiers.  There is a list of these structures
- * for each display.
+ * A structure of the following type is used to hold one or more available
+ * resource identifiers. There is a list of these structures for each display.
  */
 
 #define IDS_PER_STACK 10
 typedef struct TkIdStack {
-    XID ids[IDS_PER_STACK];		/* Array of free identifiers. */
-    int numUsed;			/* Indicates how many of the entries
-					 * in ids are currently in use. */
-    TkDisplay *dispPtr;			/* Display to which ids belong. */
-    struct TkIdStack *nextPtr;		/* Next bunch of free identifiers
-					 * for the same display. */
+    XID ids[IDS_PER_STACK];	/* Array of free identifiers. */
+    int numUsed;		/* Indicates how many of the entries in ids
+				 * are currently in use. */
+    TkDisplay *dispPtr;		/* Display to which ids belong. */
+    struct TkIdStack *nextPtr;	/* Next bunch of free identifiers for the same
+				 * display. */
 } TkIdStack;
 
 /*
- * Forward declarations for procedures defined in this file:
+ * Forward declarations for functions defined in this file:
  */
 
-static XID		AllocXId _ANSI_ARGS_((Display *display));
-static Tk_RestrictAction CheckRestrictProc _ANSI_ARGS_((
-			    ClientData clientData, XEvent *eventPtr));
-static void		WindowIdCleanup _ANSI_ARGS_((ClientData clientData));
-static void		WindowIdCleanup2 _ANSI_ARGS_((ClientData clientData));
+static XID		AllocXId(Display *display);
+static Tk_RestrictAction CheckRestrictProc(ClientData clientData,
+			    XEvent *eventPtr);
+static void		WindowIdCleanup(ClientData clientData);
+static void		WindowIdCleanup2(ClientData clientData);
 
 /*
  *----------------------------------------------------------------------
  *
  * TkInitXId --
  *
- *	This procedure is called to initialize the id allocator for
- *	a given display.
+ *	This function is called to initialize the id allocator for a given
+ *	display.
  *
  * Results:
  *	None.
@@ -75,13 +73,12 @@ static void		WindowIdCleanup2 _ANSI_ARGS_((ClientData clientData));
  */
 
 void
-TkInitXId(dispPtr)
-    TkDisplay *dispPtr;			/* Tk's information about the
-					 * display. */
+TkInitXId(
+    TkDisplay *dispPtr)		/* Tk's information about the display. */
 {
     dispPtr->idStackPtr = NULL;
-    dispPtr->defaultAllocProc = (XID (*) _ANSI_ARGS_((Display *display))) 
-            dispPtr->display->resource_alloc;
+    dispPtr->defaultAllocProc = (XID (*) _ANSI_ARGS_((Display *display)))
+	    dispPtr->display->resource_alloc;
     dispPtr->display->resource_alloc = AllocXId;
     dispPtr->windowStackPtr = NULL;
     dispPtr->idCleanupScheduled = (Tcl_TimerToken) 0;
@@ -92,8 +89,8 @@ TkInitXId(dispPtr)
  *
  * TkFreeXId --
  *
- *	This procedure is called to free resources for the id allocator
- *	for a given display.
+ *	This function is called to free resources for the id allocator for a
+ *	given display.
  *
  * Results:
  *	None.
@@ -105,9 +102,8 @@ TkInitXId(dispPtr)
  */
 
 void
-TkFreeXId(dispPtr)
-    TkDisplay *dispPtr;			/* Tk's information about the
-					 * display. */
+TkFreeXId(
+    TkDisplay *dispPtr)		/* Tk's information about the display. */
 {
     TkIdStack *stackPtr, *freePtr;
 
@@ -135,23 +131,23 @@ TkFreeXId(dispPtr)
  *
  * AllocXId --
  *
- *	This procedure is invoked by Xlib as the resource allocator
- *	for a display.
+ *	This function is invoked by Xlib as the resource allocator for a
+ *	display.
  *
  * Results:
- *	The return value is an X resource identifier that isn't currently
- *	in use.
+ *	The return value is an X resource identifier that isn't currently in
+ *	use.
  *
  * Side effects:
- *	The identifier is removed from the stack of free identifiers,
- *	if it was previously on the stack.
+ *	The identifier is removed from the stack of free identifiers, if it
+ *	was previously on the stack.
  *
  *----------------------------------------------------------------------
  */
 
 static XID
-AllocXId(display)
-    Display *display;			/* Display for which to allocate. */
+AllocXId(
+    Display *display)		/* Display for which to allocate. */
 {
     TkDisplay *dispPtr;
     TkIdStack *stackPtr;
@@ -161,10 +157,10 @@ AllocXId(display)
      */
 
     dispPtr = TkGetDisplay(display);
-    
+
     /*
-     * If the topmost chunk on the stack is empty then free it.  Then
-     * check for a free id on the stack and return it if it exists.
+     * If the topmost chunk on the stack is empty then free it. Then check for
+     * a free id on the stack and return it if it exists.
      */
 
     stackPtr = dispPtr->idStackPtr;
@@ -182,11 +178,10 @@ AllocXId(display)
     }
 
     /*
-     * No free ids in the stack:  just get one from the default
-     * allocator.
+     * No free ids in the stack: just get one from the default allocator.
      */
 
-    defAlloc:
+  defAlloc:
     return (*dispPtr->defaultAllocProc)(display);
 }
 
@@ -195,8 +190,8 @@ AllocXId(display)
  *
  * Tk_FreeXId --
  *
- *	This procedure is called to indicate that an X resource identifier
- *	is now free.
+ *	This function is called to indicate that an X resource identifier is
+ *	now free.
  *
  * Results:
  *	None.
@@ -209,11 +204,9 @@ AllocXId(display)
  */
 
 void
-Tk_FreeXId(display, xid)
-    Display *display;			/* Display for which xid was
-					 * allocated. */
-    XID xid;				/* Identifier that is no longer
-					 * in use. */
+Tk_FreeXId(
+    Display *display,		/* Display for which xid was allocated. */
+    XID xid)			/* Identifier that is no longer in use. */
 {
     TkDisplay *dispPtr;
     TkIdStack *stackPtr;
@@ -227,7 +220,7 @@ Tk_FreeXId(display, xid)
     /*
      * Add a new chunk to the stack if the current chunk is full.
      */
-    
+
     stackPtr = dispPtr->idStackPtr;
     if ((stackPtr == NULL) || (stackPtr->numUsed >= IDS_PER_STACK)) {
 	stackPtr = (TkIdStack *) ckalloc(sizeof(TkIdStack));
@@ -250,68 +243,64 @@ Tk_FreeXId(display, xid)
  *
  * TkFreeWindowId --
  *
- *	This procedure is invoked instead of TkFreeXId for window ids.
- *	See below for the reason why.
+ *	This function is invoked instead of TkFreeXId for window ids. See
+ *	below for the reason why.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The id given by w will eventually be freed, so that it can be
- *	reused for other resources.
+ *	The id given by w will eventually be freed, so that it can be reused
+ *	for other resources.
  *
  * Design:
- *	Freeing window ids is very tricky because there could still be
- *	events pending for a window in the event queue (or even in the
- *	server) at the time the window is destroyed.  If the window
- *	id were to get reused immediately for another window, old
- *	events could "drop in" on the new window, causing unexpected
- *	behavior.
- *
- *	Thus we have to wait to re-use a window id until we know that
- *	there are no events left for it.  Right now this is done in
- *	two steps.  First, we wait until we know that the server
- *	has seen the XDestroyWindow request, so we can be sure that
- *	it won't generate more events for the window and that any
- *	existing events are in our queue.  Second, we make sure that
- *	there are no events whatsoever in our queue (this is conservative
- *	but safe).
- *
- * 	The first step is done by remembering the request id of the
- *	XDestroyWindow request and using LastKnownRequestProcessed to
- *	see what events the server has processed.  If multiple windows
- *	get destroyed at about the same time, we just remember the
- *	most recent request number for any of them (again, conservative
- *	but safe).
- *
- *	There are a few other complications as well.  When Tk destroys a
- *	sub-tree of windows, it only issues a single XDestroyWindow call,
- *	at the very end for the root of the subtree.  We can't free any of
- *	the window ids until the final XDestroyWindow call.  To make sure
- *	that this happens, we have to keep track of deletions in progress,
- *	hence the need for the "destroyCount" field of the display.
- *
- *	One final problem.  Some servers, like Sun X11/News servers still
- *	seem to have problems with ids getting reused too quickly.  I'm
- *	not completely sure why this is a problem, but delaying the
- *	recycling of ids appears to eliminate it.  Therefore, we wait
- *	an additional few seconds, even after "the coast is clear"
- *	before reusing the ids.
+ *	Freeing window ids is very tricky because there could still be events
+ *	pending for a window in the event queue (or even in the server) at the
+ *	time the window is destroyed. If the window id were to get reused
+ *	immediately for another window, old events could "drop in" on the new
+ *	window, causing unexpected behavior.
+ *
+ *	Thus we have to wait to re-use a window id until we know that there
+ *	are no events left for it. Right now this is done in two steps. First,
+ *	we wait until we know that the server has seen the XDestroyWindow
+ *	request, so we can be sure that it won't generate more events for the
+ *	window and that any existing events are in our queue. Second, we make
+ *	sure that there are no events whatsoever in our queue (this is
+ *	conservative but safe).
+ *
+ *	The first step is done by remembering the request id of the
+ *	XDestroyWindow request and using LastKnownRequestProcessed to see what
+ *	events the server has processed. If multiple windows get destroyed at
+ *	about the same time, we just remember the most recent request number
+ *	for any of them (again, conservative but safe).
+ *
+ *	There are a few other complications as well. When Tk destroys a
+ *	sub-tree of windows, it only issues a single XDestroyWindow call, at
+ *	the very end for the root of the subtree. We can't free any of the
+ *	window ids until the final XDestroyWindow call. To make sure that this
+ *	happens, we have to keep track of deletions in progress, hence the
+ *	need for the "destroyCount" field of the display.
+ *
+ *	One final problem. Some servers, like Sun X11/News servers still seem
+ *	to have problems with ids getting reused too quickly. I'm not
+ *	completely sure why this is a problem, but delaying the recycling of
+ *	ids appears to eliminate it. Therefore, we wait an additional few
+ *	seconds, even after "the coast is clear" before reusing the ids.
  *
  *----------------------------------------------------------------------
  */
 
 void
-TkFreeWindowId(dispPtr, w)
-    TkDisplay *dispPtr;		/* Display that w belongs to. */
-    Window w;			/* X identifier for window on dispPtr. */
+TkFreeWindowId(
+    TkDisplay *dispPtr,		/* Display that w belongs to. */
+    Window w)			/* X identifier for window on dispPtr. */
 {
     TkIdStack *stackPtr;
 
     /*
-     * Put the window id on a separate stack of window ids, rather
-     * than the main stack, so it won't get reused right away.  Add
-     * a new chunk to the stack if the current chunk is full.
+     * Put the window id on a separate stack of window ids, rather than the
+     * main stack, so it won't get reused right away. Add a new chunk to the
+     * stack if the current chunk is full.
      */
 
     stackPtr = dispPtr->windowStackPtr;
@@ -331,13 +320,12 @@ TkFreeWindowId(dispPtr, w)
     stackPtr->numUsed++;
 
     /*
-     * Schedule a call to WindowIdCleanup if one isn't already
-     * scheduled.
+     * Schedule a call to WindowIdCleanup if one isn't already scheduled.
      */
 
     if (!dispPtr->idCleanupScheduled) {
-	dispPtr->idCleanupScheduled =
-	    Tcl_CreateTimerHandler(100, WindowIdCleanup, (ClientData) dispPtr);
+	dispPtr->idCleanupScheduled = Tcl_CreateTimerHandler(100,
+		WindowIdCleanup, (ClientData) dispPtr);
     }
 }
 
@@ -346,24 +334,23 @@ TkFreeWindowId(dispPtr, w)
  *
  * WindowIdCleanup --
  *
- *	See if we can now free up all the accumulated ids of
- *	deleted windows.
+ *	See if we can now free up all the accumulated ids of deleted windows.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	If it's safe to move the window ids back to the main free
- *	list, we schedule this to happen after a few mores seconds
- *	of delay.  If it's not safe to move them yet, a timer handler
- *	gets invoked to try again later.
+ *	If it's safe to move the window ids back to the main free list, we
+ *	schedule this to happen after a few mores seconds of delay. If it's
+ *	not safe to move them yet, a timer handler gets invoked to try again
+ *	later.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-WindowIdCleanup(clientData)
-    ClientData clientData;	/* Pointer to TkDisplay for display */
+WindowIdCleanup(
+    ClientData clientData)	/* Pointer to TkDisplay for display */
 {
     TkDisplay *dispPtr = (TkDisplay *) clientData;
     int anyEvents, delta;
@@ -374,14 +361,14 @@ WindowIdCleanup(clientData)
     dispPtr->idCleanupScheduled = (Tcl_TimerToken) 0;
 
     /*
-     * See if it's safe to recycle the window ids.  It's safe if:
+     * See if it's safe to recycle the window ids. It's safe if:
      * (a) no deletions are in progress.
      * (b) the server has seen all of the requests up to the last
      *     XDestroyWindow request.
-     * (c) there are no events in the event queue; the only way to
-     *     test for this right now is to create a restrict proc that
-     *     will filter the events, then call Tcl_DoOneEvent to see if
-     *	   the procedure gets invoked.
+     * (c) there are no events in the event queue; the only way to test for
+     *     this right now is to create a restrict proc that will filter the
+     *     events, then call Tcl_DoOneEvent to see if the function gets
+     *     invoked.
      */
 
     if (dispPtr->destroyCount > 0) {
@@ -402,8 +389,8 @@ WindowIdCleanup(clientData)
     }
 
     /*
-     * These ids look safe to recycle, but we still need to delay a bit
-     * more (see comments for TkFreeWindowId).  Schedule the final freeing.
+     * These ids look safe to recycle, but we still need to delay a bit more
+     * (see comments for TkFreeWindowId). Schedule the final freeing.
      */
 
     if (dispPtr->windowStackPtr != NULL) {
@@ -414,12 +401,12 @@ WindowIdCleanup(clientData)
     return;
 
     /*
-     * It's still not safe to free up the ids.  Try again a bit later.
+     * It's still not safe to free up the ids. Try again a bit later.
      */
 
-    tryAgain:
-    dispPtr->idCleanupScheduled =
-	Tcl_CreateTimerHandler(500, WindowIdCleanup, (ClientData) dispPtr);
+  tryAgain:
+    dispPtr->idCleanupScheduled = Tcl_CreateTimerHandler(500,
+	    WindowIdCleanup, (ClientData) dispPtr);
 }
 
 /*
@@ -427,9 +414,9 @@ WindowIdCleanup(clientData)
  *
  * WindowIdCleanup2 --
  *
- *	This procedure is the last one in the chain that recycles
- *	window ids.  It takes all of the ids indicated by its
- *	argument and adds them back to the main id free list.
+ *	This function is the last one in the chain that recycles window ids.
+ *	It takes all of the ids indicated by its argument and adds them back
+ *	to the main id free list.
  *
  * Results:
  *	None.
@@ -441,8 +428,8 @@ WindowIdCleanup(clientData)
  */
 
 static void
-WindowIdCleanup2(clientData)
-    ClientData clientData;	/* Pointer to TkIdStack list. */
+WindowIdCleanup2(
+    ClientData clientData)	/* Pointer to TkIdStack list. */
 {
     TkIdStack *stackPtr = (TkIdStack *) clientData;
     TkIdStack *lastPtr;
@@ -460,9 +447,9 @@ WindowIdCleanup2(clientData)
  *
  * CheckRestrictProc --
  *
- *	This procedure is a restrict procedure, called by Tcl_DoOneEvent
- *	to filter X events.  All it does is to set a flag to indicate
- *	that there are X events present.
+ *	This function is a restrict function, called by Tcl_DoOneEvent to
+ *	filter X events. All it does is to set a flag to indicate that there
+ *	are X events present.
  *
  * Results:
  *	Sets the integer pointed to by the argument, then returns
@@ -475,9 +462,9 @@ WindowIdCleanup2(clientData)
  */
 
 static Tk_RestrictAction
-CheckRestrictProc(clientData, eventPtr)
-    ClientData clientData;	/* Pointer to flag to set. */
-    XEvent *eventPtr;		/* Event to filter;  not used. */
+CheckRestrictProc(
+    ClientData clientData,	/* Pointer to flag to set. */
+    XEvent *eventPtr)		/* Event to filter; not used. */
 {
     int *flag = (int *) clientData;
     *flag = 1;
@@ -489,8 +476,8 @@ CheckRestrictProc(clientData, eventPtr)
  *
  * Tk_GetPixmap --
  *
- *	Same as the XCreatePixmap procedure except that it manages
- *	resource identifiers better.
+ *	Same as the XCreatePixmap function except that it manages resource
+ *	identifiers better.
  *
  * Results:
  *	Returns a new pixmap.
@@ -502,11 +489,11 @@ CheckRestrictProc(clientData, eventPtr)
  */
 
 Pixmap
-Tk_GetPixmap(display, d, width, height, depth)
-    Display *display;		/* Display for new pixmap. */
-    Drawable d;			/* Drawable where pixmap will be used. */
-    int width, height;		/* Dimensions of pixmap. */
-    int depth;			/* Bits per pixel for pixmap. */
+Tk_GetPixmap(
+    Display *display,		/* Display for new pixmap. */
+    Drawable d,			/* Drawable where pixmap will be used. */
+    int width, int height,	/* Dimensions of pixmap. */
+    int depth)			/* Bits per pixel for pixmap. */
 {
     return XCreatePixmap(display, d, (unsigned) width, (unsigned) height,
 	    (unsigned) depth);
@@ -517,23 +504,23 @@ Tk_GetPixmap(display, d, width, height, depth)
  *
  * Tk_FreePixmap --
  *
- *	Same as the XFreePixmap procedure except that it also marks
- *	the resource identifier as free.
+ *	Same as the XFreePixmap function except that it also marks the
+ *	resource identifier as free.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The pixmap is freed in the X server and its resource identifier
- *	is saved for re-use.
+ *	The pixmap is freed in the X server and its resource identifier is
+ *	saved for re-use.
  *
  *----------------------------------------------------------------------
  */
 
 void
-Tk_FreePixmap(display, pixmap)
-    Display *display;		/* Display for which pixmap was allocated. */
-    Pixmap pixmap;		/* Identifier for pixmap. */
+Tk_FreePixmap(
+    Display *display,		/* Display for which pixmap was allocated. */
+    Pixmap pixmap)		/* Identifier for pixmap. */
 {
     XFreePixmap(display, pixmap);
     Tk_FreeXId(display, (XID) pixmap);
@@ -544,10 +531,10 @@ Tk_FreePixmap(display, pixmap)
  *
  * TkpWindowWasRecentlyDeleted --
  *
- *	Checks whether the window was recently deleted. This is called
- *	by the generic error handler to detect asynchronous notification
- *	of errors due to operations by Tk on a window that was already
- *	deleted by the server.
+ *	Checks whether the window was recently deleted. This is called by the
+ *	generic error handler to detect asynchronous notification of errors
+ *	due to operations by Tk on a window that was already deleted by the
+ *	server.
  *
  * Results:
  *	1 if the window was deleted recently, 0 otherwise.
@@ -559,21 +546,20 @@ Tk_FreePixmap(display, pixmap)
  */
 
 int
-TkpWindowWasRecentlyDeleted(win, dispPtr)
-    Window win;		/* The window to check for. */
-    TkDisplay *dispPtr;	/* The window belongs to this display. */
+TkpWindowWasRecentlyDeleted(
+    Window win,			/* The window to check for. */
+    TkDisplay *dispPtr)		/* The window belongs to this display. */
 {
     TkIdStack *stackPtr;
     int i;
 
-    for (stackPtr = dispPtr->windowStackPtr;
-         stackPtr != NULL;
-         stackPtr = stackPtr->nextPtr) {
-        for (i = 0; i < stackPtr->numUsed; i++) {
-            if ((Window) stackPtr->ids[i] == win) {
-                return 1;
-            }
-        }
+    for (stackPtr = dispPtr->windowStackPtr; stackPtr != NULL;
+	    stackPtr = stackPtr->nextPtr) {
+	for (i = 0; i < stackPtr->numUsed; i++) {
+	    if ((Window) stackPtr->ids[i] == win) {
+		return 1;
+	    }
+	}
     }
     return 0;
 }
@@ -586,10 +572,10 @@ TkpWindowWasRecentlyDeleted(win, dispPtr)
  *	Given a string, produce the corresponding Window Id.
  *
  * Results:
- *      The return value is normally TCL_OK;  in this case *idPtr
- *      will be set to the Window value equivalent to string.  If
- *      string is improperly formed then TCL_ERROR is returned and
- *      an error message will be left in the interp's result.
+ *	The return value is normally TCL_OK; in this case *idPtr will be set
+ *	to the Window value equivalent to string. If string is improperly
+ *	formed then TCL_ERROR is returned and an error message will be left in
+ *	the interp's result.
  *
  * Side effects:
  *	None.
@@ -598,16 +584,24 @@ TkpWindowWasRecentlyDeleted(win, dispPtr)
  */
 
 int
-TkpScanWindowId(interp, string, idPtr)
-    Tcl_Interp *interp;	
-    CONST char *string;
-    Window *idPtr;
+TkpScanWindowId(
+    Tcl_Interp *interp,
+    CONST char *string,
+    Window *idPtr)
 {
     int value;
+
     if (Tcl_GetInt(interp, string, &value) != TCL_OK) {
 	return TCL_ERROR;
     }
     *idPtr = (Window) value;
     return TCL_OK;
 }
-
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */